@zuplo/cli 7.0.1 → 7.1.0

package/node_modules/@pinojs/redact/index.js

@@ -0,0 +1,529 @@
+'use strict'
+
+function deepClone (obj) {
+  if (obj === null || typeof obj !== 'object') {
+    return obj
+  }
+
+  if (obj instanceof Date) {
+    return new Date(obj.getTime())
+  }
+
+  if (obj instanceof Array) {
+    const cloned = []
+    for (let i = 0; i < obj.length; i++) {
+      cloned[i] = deepClone(obj[i])
+    }
+    return cloned
+  }
+
+  if (typeof obj === 'object') {
+    const cloned = Object.create(Object.getPrototypeOf(obj))
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        cloned[key] = deepClone(obj[key])
+      }
+    }
+    return cloned
+  }
+
+  return obj
+}
+
+function parsePath (path) {
+  const parts = []
+  let current = ''
+  let inBrackets = false
+  let inQuotes = false
+  let quoteChar = ''
+
+  for (let i = 0; i < path.length; i++) {
+    const char = path[i]
+
+    if (!inBrackets && char === '.') {
+      if (current) {
+        parts.push(current)
+        current = ''
+      }
+    } else if (char === '[') {
+      if (current) {
+        parts.push(current)
+        current = ''
+      }
+      inBrackets = true
+    } else if (char === ']' && inBrackets) {
+      // Always push the current value when closing brackets, even if it's an empty string
+      parts.push(current)
+      current = ''
+      inBrackets = false
+      inQuotes = false
+    } else if ((char === '"' || char === "'") && inBrackets) {
+      if (!inQuotes) {
+        inQuotes = true
+        quoteChar = char
+      } else if (char === quoteChar) {
+        inQuotes = false
+        quoteChar = ''
+      } else {
+        current += char
+      }
+    } else {
+      current += char
+    }
+  }
+
+  if (current) {
+    parts.push(current)
+  }
+
+  return parts
+}
+
+function setValue (obj, parts, value) {
+  let current = obj
+
+  for (let i = 0; i < parts.length - 1; i++) {
+    const key = parts[i]
+    // Type safety: Check if current is an object before using 'in' operator
+    if (typeof current !== 'object' || current === null || !(key in current)) {
+      return false // Path doesn't exist, don't create it
+    }
+    if (typeof current[key] !== 'object' || current[key] === null) {
+      return false // Path doesn't exist properly
+    }
+    current = current[key]
+  }
+
+  const lastKey = parts[parts.length - 1]
+  if (lastKey === '*') {
+    if (Array.isArray(current)) {
+      for (let i = 0; i < current.length; i++) {
+        current[i] = value
+      }
+    } else if (typeof current === 'object' && current !== null) {
+      for (const key in current) {
+        if (Object.prototype.hasOwnProperty.call(current, key)) {
+          current[key] = value
+        }
+      }
+    }
+  } else {
+    // Type safety: Check if current is an object before using 'in' operator
+    if (typeof current === 'object' && current !== null && lastKey in current && Object.prototype.hasOwnProperty.call(current, lastKey)) {
+      current[lastKey] = value
+    }
+  }
+  return true
+}
+
+function removeKey (obj, parts) {
+  let current = obj
+
+  for (let i = 0; i < parts.length - 1; i++) {
+    const key = parts[i]
+    // Type safety: Check if current is an object before using 'in' operator
+    if (typeof current !== 'object' || current === null || !(key in current)) {
+      return false // Path doesn't exist, don't create it
+    }
+    if (typeof current[key] !== 'object' || current[key] === null) {
+      return false // Path doesn't exist properly
+    }
+    current = current[key]
+  }
+
+  const lastKey = parts[parts.length - 1]
+  if (lastKey === '*') {
+    if (Array.isArray(current)) {
+      // For arrays, we can't really "remove" all items as that would change indices
+      // Instead, we set them to undefined which will be omitted by JSON.stringify
+      for (let i = 0; i < current.length; i++) {
+        current[i] = undefined
+      }
+    } else if (typeof current === 'object' && current !== null) {
+      for (const key in current) {
+        if (Object.prototype.hasOwnProperty.call(current, key)) {
+          delete current[key]
+        }
+      }
+    }
+  } else {
+    // Type safety: Check if current is an object before using 'in' operator
+    if (typeof current === 'object' && current !== null && lastKey in current && Object.prototype.hasOwnProperty.call(current, lastKey)) {
+      delete current[lastKey]
+    }
+  }
+  return true
+}
+
+// Sentinel object to distinguish between undefined value and non-existent path
+const PATH_NOT_FOUND = Symbol('PATH_NOT_FOUND')
+
+function getValueIfExists (obj, parts) {
+  let current = obj
+
+  for (const part of parts) {
+    if (current === null || current === undefined) {
+      return PATH_NOT_FOUND
+    }
+    // Type safety: Check if current is an object before property access
+    if (typeof current !== 'object' || current === null) {
+      return PATH_NOT_FOUND
+    }
+    // Check if the property exists before accessing it
+    if (!(part in current)) {
+      return PATH_NOT_FOUND
+    }
+    current = current[part]
+  }
+
+  return current
+}
+
+function getValue (obj, parts) {
+  let current = obj
+
+  for (const part of parts) {
+    if (current === null || current === undefined) {
+      return undefined
+    }
+    // Type safety: Check if current is an object before property access
+    if (typeof current !== 'object' || current === null) {
+      return undefined
+    }
+    current = current[part]
+  }
+
+  return current
+}
+
+function redactPaths (obj, paths, censor, remove = false) {
+  for (const path of paths) {
+    const parts = parsePath(path)
+
+    if (parts.includes('*')) {
+      redactWildcardPath(obj, parts, censor, path, remove)
+    } else {
+      if (remove) {
+        removeKey(obj, parts)
+      } else {
+        // Get value only if path exists - single traversal
+        const value = getValueIfExists(obj, parts)
+        if (value === PATH_NOT_FOUND) {
+          continue
+        }
+
+        const actualCensor = typeof censor === 'function'
+          ? censor(value, parts)
+          : censor
+        setValue(obj, parts, actualCensor)
+      }
+    }
+  }
+}
+
+function redactWildcardPath (obj, parts, censor, originalPath, remove = false) {
+  const wildcardIndex = parts.indexOf('*')
+
+  if (wildcardIndex === parts.length - 1) {
+    const parentParts = parts.slice(0, -1)
+    let current = obj
+
+    for (const part of parentParts) {
+      if (current === null || current === undefined) return
+      // Type safety: Check if current is an object before property access
+      if (typeof current !== 'object' || current === null) return
+      current = current[part]
+    }
+
+    if (Array.isArray(current)) {
+      if (remove) {
+        // For arrays, set all items to undefined which will be omitted by JSON.stringify
+        for (let i = 0; i < current.length; i++) {
+          current[i] = undefined
+        }
+      } else {
+        for (let i = 0; i < current.length; i++) {
+          const indexPath = [...parentParts, i.toString()]
+          const actualCensor = typeof censor === 'function'
+            ? censor(current[i], indexPath)
+            : censor
+          current[i] = actualCensor
+        }
+      }
+    } else if (typeof current === 'object' && current !== null) {
+      if (remove) {
+        // Collect keys to delete to avoid issues with deleting during iteration
+        const keysToDelete = []
+        for (const key in current) {
+          if (Object.prototype.hasOwnProperty.call(current, key)) {
+            keysToDelete.push(key)
+          }
+        }
+        for (const key of keysToDelete) {
+          delete current[key]
+        }
+      } else {
+        for (const key in current) {
+          const keyPath = [...parentParts, key]
+          const actualCensor = typeof censor === 'function'
+            ? censor(current[key], keyPath)
+            : censor
+          current[key] = actualCensor
+        }
+      }
+    }
+  } else {
+    redactIntermediateWildcard(obj, parts, censor, wildcardIndex, originalPath, remove)
+  }
+}
+
+function redactIntermediateWildcard (obj, parts, censor, wildcardIndex, originalPath, remove = false) {
+  const beforeWildcard = parts.slice(0, wildcardIndex)
+  const afterWildcard = parts.slice(wildcardIndex + 1)
+  const pathArray = [] // Cached array to avoid allocations
+
+  function traverse (current, pathLength) {
+    if (pathLength === beforeWildcard.length) {
+      if (Array.isArray(current)) {
+        for (let i = 0; i < current.length; i++) {
+          pathArray[pathLength] = i.toString()
+          traverse(current[i], pathLength + 1)
+        }
+      } else if (typeof current === 'object' && current !== null) {
+        for (const key in current) {
+          pathArray[pathLength] = key
+          traverse(current[key], pathLength + 1)
+        }
+      }
+    } else if (pathLength < beforeWildcard.length) {
+      const nextKey = beforeWildcard[pathLength]
+      // Type safety: Check if current is an object before using 'in' operator
+      if (current && typeof current === 'object' && current !== null && nextKey in current) {
+        pathArray[pathLength] = nextKey
+        traverse(current[nextKey], pathLength + 1)
+      }
+    } else {
+      // Check if afterWildcard contains more wildcards
+      if (afterWildcard.includes('*')) {
+        // Recursively handle remaining wildcards
+        // Wrap censor to prepend current path context
+        const wrappedCensor = typeof censor === 'function'
+          ? (value, path) => {
+              const fullPath = [...pathArray.slice(0, pathLength), ...path]
+              return censor(value, fullPath)
+            }
+          : censor
+        redactWildcardPath(current, afterWildcard, wrappedCensor, originalPath, remove)
+      } else {
+        // No more wildcards, apply the redaction directly
+        if (remove) {
+          removeKey(current, afterWildcard)
+        } else {
+          const actualCensor = typeof censor === 'function'
+            ? censor(getValue(current, afterWildcard), [...pathArray.slice(0, pathLength), ...afterWildcard])
+            : censor
+          setValue(current, afterWildcard, actualCensor)
+        }
+      }
+    }
+  }
+
+  if (beforeWildcard.length === 0) {
+    traverse(obj, 0)
+  } else {
+    let current = obj
+    for (let i = 0; i < beforeWildcard.length; i++) {
+      const part = beforeWildcard[i]
+      if (current === null || current === undefined) return
+      // Type safety: Check if current is an object before property access
+      if (typeof current !== 'object' || current === null) return
+      current = current[part]
+      pathArray[i] = part
+    }
+    if (current !== null && current !== undefined) {
+      traverse(current, beforeWildcard.length)
+    }
+  }
+}
+
+function buildPathStructure (pathsToClone) {
+  if (pathsToClone.length === 0) {
+    return null // No paths to redact
+  }
+
+  // Parse all paths and organize by depth
+  const pathStructure = new Map()
+  for (const path of pathsToClone) {
+    const parts = parsePath(path)
+    let current = pathStructure
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i]
+      if (!current.has(part)) {
+        current.set(part, new Map())
+      }
+      current = current.get(part)
+    }
+  }
+  return pathStructure
+}
+
+function selectiveClone (obj, pathStructure) {
+  if (!pathStructure) {
+    return obj // No paths to redact, return original
+  }
+
+  function cloneSelectively (source, pathMap, depth = 0) {
+    if (!pathMap || pathMap.size === 0) {
+      return source // No more paths to clone, return reference
+    }
+
+    if (source === null || typeof source !== 'object') {
+      return source
+    }
+
+    if (source instanceof Date) {
+      return new Date(source.getTime())
+    }
+
+    if (Array.isArray(source)) {
+      const cloned = []
+      for (let i = 0; i < source.length; i++) {
+        const indexStr = i.toString()
+        if (pathMap.has(indexStr) || pathMap.has('*')) {
+          cloned[i] = cloneSelectively(source[i], pathMap.get(indexStr) || pathMap.get('*'))
+        } else {
+          cloned[i] = source[i] // Share reference for non-redacted items
+        }
+      }
+      return cloned
+    }
+
+    // Handle objects
+    const cloned = Object.create(Object.getPrototypeOf(source))
+    for (const key in source) {
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        if (pathMap.has(key) || pathMap.has('*')) {
+          cloned[key] = cloneSelectively(source[key], pathMap.get(key) || pathMap.get('*'))
+        } else {
+          cloned[key] = source[key] // Share reference for non-redacted properties
+        }
+      }
+    }
+    return cloned
+  }
+
+  return cloneSelectively(obj, pathStructure)
+}
+
+function validatePath (path) {
+  if (typeof path !== 'string') {
+    throw new Error('Paths must be (non-empty) strings')
+  }
+
+  if (path === '') {
+    throw new Error('Invalid redaction path ()')
+  }
+
+  // Check for double dots
+  if (path.includes('..')) {
+    throw new Error(`Invalid redaction path (${path})`)
+  }
+
+  // Check for comma-separated paths (invalid syntax)
+  if (path.includes(',')) {
+    throw new Error(`Invalid redaction path (${path})`)
+  }
+
+  // Check for unmatched brackets
+  let bracketCount = 0
+  let inQuotes = false
+  let quoteChar = ''
+
+  for (let i = 0; i < path.length; i++) {
+    const char = path[i]
+
+    if ((char === '"' || char === "'") && bracketCount > 0) {
+      if (!inQuotes) {
+        inQuotes = true
+        quoteChar = char
+      } else if (char === quoteChar) {
+        inQuotes = false
+        quoteChar = ''
+      }
+    } else if (char === '[' && !inQuotes) {
+      bracketCount++
+    } else if (char === ']' && !inQuotes) {
+      bracketCount--
+      if (bracketCount < 0) {
+        throw new Error(`Invalid redaction path (${path})`)
+      }
+    }
+  }
+
+  if (bracketCount !== 0) {
+    throw new Error(`Invalid redaction path (${path})`)
+  }
+}
+
+function validatePaths (paths) {
+  if (!Array.isArray(paths)) {
+    throw new TypeError('paths must be an array')
+  }
+
+  for (const path of paths) {
+    validatePath(path)
+  }
+}
+
+function slowRedact (options = {}) {
+  const {
+    paths = [],
+    censor = '[REDACTED]',
+    serialize = JSON.stringify,
+    strict = true,
+    remove = false
+  } = options
+
+  // Validate paths upfront to match fast-redact behavior
+  validatePaths(paths)
+
+  // Build path structure once during setup, not on every call
+  const pathStructure = buildPathStructure(paths)
+
+  return function redact (obj) {
+    if (strict && (obj === null || typeof obj !== 'object')) {
+      if (obj === null || obj === undefined) {
+        return serialize ? serialize(obj) : obj
+      }
+      if (typeof obj !== 'object') {
+        return serialize ? serialize(obj) : obj
+      }
+    }
+
+    // Only clone paths that need redaction
+    const cloned = selectiveClone(obj, pathStructure)
+    const original = obj // Keep reference to original for restore
+
+    let actualCensor = censor
+    if (typeof censor === 'function') {
+      actualCensor = censor
+    }
+
+    redactPaths(cloned, paths, actualCensor, remove)
+
+    if (serialize === false) {
+      cloned.restore = function () {
+        return deepClone(original) // Full clone only when restore is called
+      }
+      return cloned
+    }
+
+    if (typeof serialize === 'function') {
+      return serialize(cloned)
+    }
+
+    return JSON.stringify(cloned)
+  }
+}
+
+module.exports = slowRedact

package/node_modules/@pinojs/redact/index.test-d.ts

@@ -0,0 +1,22 @@
+import { expectType, expectAssignable } from "tsd";
+import slowRedact from ".";
+import type { redactFn, redactFnNoSerialize } from ".";
+
+// should return redactFn
+expectType<redactFn>(slowRedact());
+expectType<redactFn>(slowRedact({ paths: [] }));
+expectType<redactFn>(slowRedact({ paths: ["some.path"] }));
+expectType<redactFn>(slowRedact({ paths: [], censor: "[REDACTED]" }));
+expectType<redactFn>(slowRedact({ paths: [], strict: true }));
+expectType<redactFn>(slowRedact({ paths: [], serialize: JSON.stringify }));
+expectType<redactFn>(slowRedact({ paths: [], serialize: true }));
+expectType<redactFnNoSerialize>(slowRedact({ paths: [], serialize: false }));
+expectType<redactFn>(slowRedact({ paths: [], remove: true }));
+
+// should return string
+expectType<string>(slowRedact()(""));
+
+// should return string or T
+expectAssignable<string | { someField: string }>(
+  slowRedact()({ someField: "someValue" })
+);

package/node_modules/@pinojs/redact/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@pinojs/redact",
+  "version": "0.4.0",
+  "description": "Redact JS objects",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "node --test && npm run test:types",
+    "test:integration": "node --test test/integration.test.js",
+    "test:types": "tsd",
+    "test:all": "node --test test/*.test.js",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "bench": "node benchmarks/basic.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pinojs/redact.git"
+  },
+  "keywords": [
+    "redact"
+  ],
+  "author": "Matteo Collina <hello@matteocollina.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/pinojs/redact/issues"
+  },
+  "homepage": "https://github.com/pinojs/redact#readme",
+  "devDependencies": {
+    "eslint": "^9.36.0",
+    "fast-redact": "^3.5.0",
+    "mitata": "^1.0.34",
+    "neostandard": "^0.12.2",
+    "tsd": "^0.33.0",
+    "typescript": "^5.9.2"
+  }
+}

package/node_modules/@pinojs/redact/scripts/sync-version.mjs

@@ -0,0 +1,20 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+const packageJsonPath = path.resolve(import.meta.dirname, '../package.json')
+let { version } = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'))
+
+let passedVersion = process.argv[2]
+
+if (passedVersion) {
+  passedVersion = passedVersion.trim().replace(/^v/, '')
+  if (version !== passedVersion) {
+    console.log(`Syncing version from ${version} to ${passedVersion}`)
+    version = passedVersion
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'))
+    packageJson.version = version
+    fs.writeFileSync(path.resolve('./package.json'), JSON.stringify(packageJson, null, 2) + '\n', { encoding: 'utf-8' })
+  }
+} else {
+  throw new Error('Version argument is required')
+}