@wbce/projen-d9 0.0.27

package/node_modules/pg-copy-streams/obuf.js

@@ -0,0 +1,376 @@
+const Buffer = require('buffer').Buffer
+
+function OffsetBuffer() {
+  this.offset = 0
+  this.size = 0
+  this.buffers = []
+}
+module.exports = OffsetBuffer
+
+OffsetBuffer.prototype.isEmpty = function isEmpty() {
+  return this.size === 0
+}
+
+OffsetBuffer.prototype.clone = function clone(size) {
+  const r = new OffsetBuffer()
+  r.offset = this.offset
+  r.size = size
+  r.buffers = this.buffers.slice()
+  return r
+}
+
+OffsetBuffer.prototype.toChunks = function toChunks() {
+  if (this.size === 0) return []
+
+  // We are going to slice it anyway
+  if (this.offset !== 0) {
+    this.buffers[0] = this.buffers[0].slice(this.offset)
+    this.offset = 0
+  }
+
+  const chunks = []
+  let off = 0
+  let i
+  for (i = 0; off <= this.size && i < this.buffers.length; i++) {
+    let buf = this.buffers[i]
+    off += buf.length
+
+    // Slice off last buffer
+    if (off > this.size) {
+      buf = buf.slice(0, buf.length - (off - this.size))
+      this.buffers[i] = buf
+    }
+
+    chunks.push(buf)
+  }
+
+  // If some buffers were skipped - trim length
+  if (i < this.buffers.length) this.buffers.length = i
+
+  return chunks
+}
+
+OffsetBuffer.prototype.toString = function toString(enc) {
+  return this.toChunks()
+    .map(function (c) {
+      return c.toString(enc)
+    })
+    .join('')
+}
+
+OffsetBuffer.prototype.use = function use(buf, off, n) {
+  this.buffers = [buf]
+  this.offset = off
+  this.size = n
+}
+
+OffsetBuffer.prototype.push = function push(data) {
+  // Ignore empty writes
+  if (data.length === 0) return
+
+  this.size += data.length
+  this.buffers.push(data)
+}
+
+OffsetBuffer.prototype.has = function has(n) {
+  return this.size >= n
+}
+
+OffsetBuffer.prototype.skip = function skip(n) {
+  if (this.size === 0) return
+
+  this.size -= n
+
+  // Fast case, skip bytes in a first buffer
+  if (this.offset + n < this.buffers[0].length) {
+    this.offset += n
+    return
+  }
+
+  let left = n - (this.buffers[0].length - this.offset)
+  this.offset = 0
+  let shift
+  for (shift = 1; left > 0 && shift < this.buffers.length; shift++) {
+    const buf = this.buffers[shift]
+    if (buf.length > left) {
+      this.offset = left
+      break
+    }
+    left -= buf.length
+  }
+  this.buffers = this.buffers.slice(shift)
+}
+
+OffsetBuffer.prototype.copy = function copy(target, targetOff, off, n) {
+  if (this.size === 0) return
+  if (off !== 0) throw new Error('Unsupported offset in .copy()')
+
+  let toff = targetOff
+  const first = this.buffers[0]
+  const toCopy = Math.min(n, first.length - this.offset)
+  first.copy(target, toff, this.offset, this.offset + toCopy)
+
+  toff += toCopy
+  let left = n - toCopy
+  for (let i = 1; left > 0 && i < this.buffers.length; i++) {
+    const buf = this.buffers[i]
+    const toCopy = Math.min(left, buf.length)
+
+    buf.copy(target, toff, 0, toCopy)
+
+    toff += toCopy
+    left -= toCopy
+  }
+}
+
+OffsetBuffer.prototype.take = function take(n) {
+  if (n === 0) return Buffer.alloc(0)
+
+  this.size -= n
+
+  // Fast cases
+  const first = this.buffers[0].length - this.offset
+  if (first === n) {
+    let r = this.buffers.shift()
+    if (this.offset !== 0) {
+      r = r.slice(this.offset)
+      this.offset = 0
+    }
+    return r
+  } else if (first > n) {
+    const r = this.buffers[0].slice(this.offset, this.offset + n)
+    this.offset += n
+    return r
+  }
+
+  // Allocate and fill buffer
+  const out = Buffer.alloc(n)
+  let toOff = 0
+  let startOff = this.offset
+  let i
+  for (i = 0; toOff !== n && i < this.buffers.length; i++) {
+    const buf = this.buffers[i]
+    const toCopy = Math.min(buf.length - startOff, n - toOff)
+
+    buf.copy(out, toOff, startOff, startOff + toCopy)
+    if (startOff + toCopy < buf.length) {
+      this.offset = startOff + toCopy
+      break
+    } else {
+      toOff += toCopy
+      startOff = 0
+    }
+  }
+
+  this.buffers = this.buffers.slice(i)
+  if (this.buffers.length === 0) this.offset = 0
+
+  return out
+}
+
+OffsetBuffer.prototype.peekUInt8 = function peekUInt8() {
+  return this.buffers[0][this.offset]
+}
+
+OffsetBuffer.prototype.readUInt8 = function readUInt8() {
+  this.size -= 1
+  const first = this.buffers[0]
+  const r = first[this.offset]
+  if (++this.offset === first.length) {
+    this.offset = 0
+    this.buffers.shift()
+  }
+
+  return r
+}
+
+OffsetBuffer.prototype.readUInt16LE = function readUInt16LE() {
+  const first = this.buffers[0]
+  this.size -= 2
+
+  let r
+  let shift
+
+  // Fast case - first buffer has all bytes
+  if (first.length - this.offset >= 2) {
+    r = first.readUInt16LE(this.offset)
+    shift = 0
+    this.offset += 2
+
+    // One byte here - one byte there
+  } else {
+    r = first[this.offset] | (this.buffers[1][0] << 8)
+    shift = 1
+    this.offset = 1
+  }
+
+  if (this.offset === this.buffers[shift].length) {
+    this.offset = 0
+    shift++
+  }
+  if (shift !== 0) this.buffers = this.buffers.slice(shift)
+
+  return r
+}
+
+OffsetBuffer.prototype.readUInt24LE = function readUInt24LE() {
+  const first = this.buffers[0]
+
+  let r
+  let shift
+  const firstHas = first.length - this.offset
+
+  // Fast case - first buffer has all bytes
+  if (firstHas >= 3) {
+    r = first.readUInt16LE(this.offset) | (first[this.offset + 2] << 16)
+    shift = 0
+    this.offset += 3
+
+    // First buffer has 2 of 3 bytes
+  } else if (firstHas >= 2) {
+    r = first.readUInt16LE(this.offset) | (this.buffers[1][0] << 16)
+    shift = 1
+    this.offset = 1
+
+    // Slow case: First buffer has 1 of 3 bytes
+  } else {
+    r = first[this.offset]
+    this.offset = 0
+    this.buffers.shift()
+    this.size -= 1
+
+    r |= this.readUInt16LE() << 8
+    return r
+  }
+
+  this.size -= 3
+  if (this.offset === this.buffers[shift].length) {
+    this.offset = 0
+    shift++
+  }
+  if (shift !== 0) this.buffers = this.buffers.slice(shift)
+
+  return r
+}
+
+OffsetBuffer.prototype.readUInt32LE = function readUInt32LE() {
+  const first = this.buffers[0]
+
+  let r
+  let shift
+  const firstHas = first.length - this.offset
+
+  // Fast case - first buffer has all bytes
+  if (firstHas >= 4) {
+    r = first.readUInt32LE(this.offset)
+    shift = 0
+    this.offset += 4
+
+    // First buffer has 3 of 4 bytes
+  } else if (firstHas >= 3) {
+    r = (first.readUInt16LE(this.offset) | (first[this.offset + 2] << 16)) + this.buffers[1][0] * 0x1000000
+    shift = 1
+    this.offset = 1
+
+    // Slow case: First buffer has 2 of 4 bytes
+  } else if (firstHas >= 2) {
+    r = first.readUInt16LE(this.offset)
+    this.offset = 0
+    this.buffers.shift()
+    this.size -= 2
+
+    r += this.readUInt16LE() * 0x10000
+    return r
+
+    // Slow case: First buffer has 1 of 4 bytes
+  } else {
+    r = first[this.offset]
+    this.offset = 0
+    this.buffers.shift()
+    this.size -= 1
+
+    r += this.readUInt24LE() * 0x100
+    return r
+  }
+
+  this.size -= 4
+  if (this.offset === this.buffers[shift].length) {
+    this.offset = 0
+    shift++
+  }
+  if (shift !== 0) this.buffers = this.buffers.slice(shift)
+
+  return r
+}
+
+OffsetBuffer.prototype.readUInt16BE = function readUInt16BE() {
+  const r = this.readUInt16LE()
+
+  return ((r & 0xff) << 8) | (r >> 8)
+}
+
+OffsetBuffer.prototype.readUInt24BE = function readUInt24BE() {
+  const r = this.readUInt24LE()
+
+  return ((r & 0xff) << 16) | (((r >> 8) & 0xff) << 8) | (r >> 16)
+}
+
+OffsetBuffer.prototype.readUInt32BE = function readUInt32BE() {
+  const r = this.readUInt32LE()
+
+  return (((r & 0xff) << 24) | (((r >>> 8) & 0xff) << 16) | (((r >>> 16) & 0xff) << 8) | (r >>> 24)) >>> 0
+}
+
+// Signed number APIs
+
+function signedInt8(num) {
+  if (num >= 0x80) return -(0xff ^ num) - 1
+  else return num
+}
+
+OffsetBuffer.prototype.peekInt8 = function peekInt8() {
+  return signedInt8(this.peekUInt8())
+}
+
+OffsetBuffer.prototype.readInt8 = function readInt8() {
+  return signedInt8(this.readUInt8())
+}
+
+function signedInt16(num) {
+  if (num >= 0x8000) return -(0xffff ^ num) - 1
+  else return num
+}
+
+OffsetBuffer.prototype.readInt16BE = function readInt16BE() {
+  return signedInt16(this.readUInt16BE())
+}
+
+OffsetBuffer.prototype.readInt16LE = function readInt16LE() {
+  return signedInt16(this.readUInt16LE())
+}
+
+function signedInt24(num) {
+  if (num >= 0x800000) return -(0xffffff ^ num) - 1
+  else return num
+}
+
+OffsetBuffer.prototype.readInt24BE = function readInt24BE() {
+  return signedInt24(this.readUInt24BE())
+}
+
+OffsetBuffer.prototype.readInt24LE = function readInt24LE() {
+  return signedInt24(this.readUInt24LE())
+}
+
+function signedInt32(num) {
+  if (num >= 0x80000000) return -(0xffffffff ^ num) - 1
+  else return num
+}
+
+OffsetBuffer.prototype.readInt32BE = function readInt32BE() {
+  return signedInt32(this.readUInt32BE())
+}
+
+OffsetBuffer.prototype.readInt32LE = function readInt32LE() {
+  return signedInt32(this.readUInt32LE())
+}

package/node_modules/pg-copy-streams/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "pg-copy-streams",
+  "version": "7.0.0",
+  "description": "Low-Level COPY TO and COPY FROM streams for PostgreSQL in JavaScript using",
+  "main": "index.js",
+  "scripts": {
+    "test": "npm run lint && mocha --v8-expose-gc",
+    "lint": "[ \"$(node -v | cut -d. -f1)\" = \"v8\" ] || eslint '**/*.{js,ts}'"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/brianc/node-pg-copy-streams.git"
+  },
+  "keywords": [
+    "postgres",
+    "copy",
+    "in",
+    "out",
+    "stream"
+  ],
+  "author": "Brian M. Carlson",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/brianc/node-pg-copy-streams/issues"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.27.0",
+    "async": "~0.2.10",
+    "benchmark": "^2.1.4",
+    "concat-stream": "^2.0.0",
+    "csv-parse": "^5.6.0",
+    "csv-parser": "^3.2.0",
+    "duplex-child-process": "^1.0.0",
+    "eslint": "^9.27.0",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-prettier": "^5.4.0",
+    "globals": "^16.2.0",
+    "lodash": "^4.17.21",
+    "mocha": "^11.5.0",
+    "pg": "^8.16.0",
+    "prettier": "^3.5.3"
+  },
+  "prettier": {
+    "semi": false,
+    "printWidth": 120,
+    "arrowParens": "always",
+    "trailingComma": "es5",
+    "singleQuote": true
+  }
+}

package/package.json

@@ -0,0 +1,136 @@
+{
+  "name": "@wbce/projen-d9",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:LaWebcapsule/projen-templates.git"
+  },
+  "bin": {
+    "wbce-d9": "lib/cli/index.js",
+    "wbce-directus": "lib/cli/index.js"
+  },
+  "author": {
+    "name": "webcapsule",
+    "email": "support@wbce.io",
+    "organization": false
+  },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "^2",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^12.20.55",
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
+    "@wbce/projen-d9-extension": "*",
+    "@wbce/projen-shared": "0.0.3",
+    "constructs": "^10.0.0",
+    "eslint": "^9",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "jest": "^30.3.0",
+    "jest-junit": "^16",
+    "jsii": "~5.9.0",
+    "jsii-diff": "^1.127.0",
+    "jsii-docgen": "^10.5.0",
+    "jsii-pacmak": "^1.127.0",
+    "jsii-rosetta": "~5.9.0",
+    "projen": "^0.99.24",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@wbce/projen-d9-extension": "*",
+    "@wbce/projen-shared": "0.0.3",
+    "constructs": "^10.6.0",
+    "projen": "^0.99.24"
+  },
+  "dependencies": {
+    "@types/pg": "^8.20.0",
+    "@types/pg-copy-streams": "^1.2.5",
+    "commander": "^14.0.3",
+    "pg": "^8.20.0",
+    "pg-copy-streams": "^7.0.0"
+  },
+  "bundledDependencies": [
+    "@types/pg",
+    "@types/pg-copy-streams",
+    "commander",
+    "pg",
+    "pg-copy-streams"
+  ],
+  "main": "lib/index.js",
+  "license": "GPL-3.0-or-later",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.0.27",
+  "jest": {
+    "coverageProvider": "v8",
+    "testMatch": [
+      "<rootDir>/@(src|test)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(src|test)/**/__tests__/**/*.ts?(x)"
+    ],
+    "clearMocks": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "lcov",
+      "clover",
+      "cobertura",
+      "text"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "watchPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "reporters": [
+      "default",
+      [
+        "jest-junit",
+        {
+          "outputDirectory": "test-reports"
+        }
+      ]
+    ],
+    "transform": {
+      "^.+\\.[t]sx?$": [
+        "ts-jest",
+        {
+          "tsconfig": "tsconfig.dev.json"
+        }
+      ]
+    }
+  },
+  "types": "lib/index.d.ts",
+  "stability": "stable",
+  "jsii": {
+    "outdir": "dist",
+    "targets": {},
+    "tsc": {
+      "outDir": "lib",
+      "rootDir": "src"
+    }
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"npx projen\".",
+  "scripts": {
+    "build": "npx projen build",
+    "compat": "npx projen compat",
+    "compile": "npx projen compile",
+    "default": "npx projen default",
+    "docgen": "npx projen docgen",
+    "eslint": "npx projen eslint",
+    "package": "npx projen package",
+    "package-all": "npx projen package-all",
+    "package:js": "npx projen package:js",
+    "post-compile": "npx projen post-compile",
+    "pre-compile": "npx projen pre-compile",
+    "test": "npx projen test",
+    "test:watch": "npx projen test:watch",
+    "watch": "npx projen watch",
+    "projen": "npx projen"
+  }
+}