@tickernelz/paperclip-pro-db 2026.925.0

package/node_modules/pg-protocol/src/testing/buffer-list.ts

@@ -0,0 +1,67 @@
+export default class BufferList {
+  constructor(public buffers: Buffer[] = []) {}
+
+  public add(buffer: Buffer, front?: boolean) {
+    this.buffers[front ? 'unshift' : 'push'](buffer)
+    return this
+  }
+
+  public addInt16(val: number, front?: boolean) {
+    return this.add(Buffer.from([val >>> 8, val >>> 0]), front)
+  }
+
+  public getByteLength() {
+    return this.buffers.reduce(function (previous, current) {
+      return previous + current.length
+    }, 0)
+  }
+
+  public addInt32(val: number, first?: boolean) {
+    return this.add(
+      Buffer.from([(val >>> 24) & 0xff, (val >>> 16) & 0xff, (val >>> 8) & 0xff, (val >>> 0) & 0xff]),
+      first
+    )
+  }
+
+  public addCString(val: string, front?: boolean) {
+    const len = Buffer.byteLength(val)
+    const buffer = Buffer.alloc(len + 1)
+    buffer.write(val)
+    buffer[len] = 0
+    return this.add(buffer, front)
+  }
+
+  public addString(val: string, front?: boolean) {
+    const len = Buffer.byteLength(val)
+    const buffer = Buffer.alloc(len)
+    buffer.write(val)
+    return this.add(buffer, front)
+  }
+
+  public addChar(char: string, first?: boolean) {
+    return this.add(Buffer.from(char, 'utf8'), first)
+  }
+
+  public addByte(byte: number) {
+    return this.add(Buffer.from([byte]))
+  }
+
+  public join(appendLength?: boolean, char?: string): Buffer {
+    let length = this.getByteLength()
+    if (appendLength) {
+      this.addInt32(length + 4, true)
+      return this.join(false, char)
+    }
+    if (char) {
+      this.addChar(char, true)
+      length++
+    }
+    const result = Buffer.alloc(length)
+    let index = 0
+    this.buffers.forEach(function (buffer) {
+      buffer.copy(result, index, 0)
+      index += buffer.length
+    })
+    return result
+  }
+}

package/node_modules/pg-protocol/src/testing/test-buffers.ts

@@ -0,0 +1,166 @@
+// https://www.postgresql.org/docs/current/protocol-message-formats.html
+import BufferList from './buffer-list'
+
+const buffers = {
+  readyForQuery: function () {
+    return new BufferList().add(Buffer.from('I')).join(true, 'Z')
+  },
+
+  authenticationOk: function () {
+    return new BufferList().addInt32(0).join(true, 'R')
+  },
+
+  authenticationCleartextPassword: function () {
+    return new BufferList().addInt32(3).join(true, 'R')
+  },
+
+  authenticationMD5Password: function () {
+    return new BufferList()
+      .addInt32(5)
+      .add(Buffer.from([1, 2, 3, 4]))
+      .join(true, 'R')
+  },
+
+  authenticationSASL: function () {
+    return new BufferList().addInt32(10).addCString('SCRAM-SHA-256').addCString('').join(true, 'R')
+  },
+
+  authenticationSASLContinue: function () {
+    return new BufferList().addInt32(11).addString('data').join(true, 'R')
+  },
+
+  authenticationSASLFinal: function () {
+    return new BufferList().addInt32(12).addString('data').join(true, 'R')
+  },
+
+  parameterStatus: function (name: string, value: string) {
+    return new BufferList().addCString(name).addCString(value).join(true, 'S')
+  },
+
+  backendKeyData: function (processID: number, secretKey: number) {
+    return new BufferList().addInt32(processID).addInt32(secretKey).join(true, 'K')
+  },
+
+  commandComplete: function (string: string) {
+    return new BufferList().addCString(string).join(true, 'C')
+  },
+
+  rowDescription: function (fields: any[]) {
+    fields = fields || []
+    const buf = new BufferList()
+    buf.addInt16(fields.length)
+    fields.forEach(function (field) {
+      buf
+        .addCString(field.name)
+        .addInt32(field.tableID || 0)
+        .addInt16(field.attributeNumber || 0)
+        .addInt32(field.dataTypeID || 0)
+        .addInt16(field.dataTypeSize || 0)
+        .addInt32(field.typeModifier || 0)
+        .addInt16(field.formatCode || 0)
+    })
+    return buf.join(true, 'T')
+  },
+
+  parameterDescription: function (dataTypeIDs: number[]) {
+    dataTypeIDs = dataTypeIDs || []
+    const buf = new BufferList()
+    buf.addInt16(dataTypeIDs.length)
+    dataTypeIDs.forEach(function (dataTypeID) {
+      buf.addInt32(dataTypeID)
+    })
+    return buf.join(true, 't')
+  },
+
+  dataRow: function (columns: any[]) {
+    columns = columns || []
+    const buf = new BufferList()
+    buf.addInt16(columns.length)
+    columns.forEach(function (col) {
+      if (col == null) {
+        buf.addInt32(-1)
+      } else {
+        const strBuf = Buffer.from(col, 'utf8')
+        buf.addInt32(strBuf.length)
+        buf.add(strBuf)
+      }
+    })
+    return buf.join(true, 'D')
+  },
+
+  error: function (fields: any) {
+    return buffers.errorOrNotice(fields).join(true, 'E')
+  },
+
+  notice: function (fields: any) {
+    return buffers.errorOrNotice(fields).join(true, 'N')
+  },
+
+  errorOrNotice: function (fields: any) {
+    fields = fields || []
+    const buf = new BufferList()
+    fields.forEach(function (field: any) {
+      buf.addChar(field.type)
+      buf.addCString(field.value)
+    })
+    return buf.add(Buffer.from([0])) // terminator
+  },
+
+  parseComplete: function () {
+    return new BufferList().join(true, '1')
+  },
+
+  bindComplete: function () {
+    return new BufferList().join(true, '2')
+  },
+
+  notification: function (id: number, channel: string, payload: string) {
+    return new BufferList().addInt32(id).addCString(channel).addCString(payload).join(true, 'A')
+  },
+
+  emptyQuery: function () {
+    return new BufferList().join(true, 'I')
+  },
+
+  portalSuspended: function () {
+    return new BufferList().join(true, 's')
+  },
+
+  closeComplete: function () {
+    return new BufferList().join(true, '3')
+  },
+
+  copyIn: function (cols: number) {
+    const list = new BufferList()
+      // text mode
+      .addByte(0)
+      // column count
+      .addInt16(cols)
+    for (let i = 0; i < cols; i++) {
+      list.addInt16(i)
+    }
+    return list.join(true, 'G')
+  },
+
+  copyOut: function (cols: number) {
+    const list = new BufferList()
+      // text mode
+      .addByte(0)
+      // column count
+      .addInt16(cols)
+    for (let i = 0; i < cols; i++) {
+      list.addInt16(i)
+    }
+    return list.join(true, 'H')
+  },
+
+  copyData: function (bytes: Buffer) {
+    return new BufferList().add(bytes).join(true, 'd')
+  },
+
+  copyDone: function () {
+    return new BufferList().join(true, 'c')
+  },
+}
+
+export default buffers

package/node_modules/pg-types/.travis.yml

@@ -0,0 +1,7 @@
+language: node_js
+node_js:
+  - '4'
+  - 'lts/*'
+  - 'node'
+env:
+  - PGUSER=postgres

package/node_modules/pg-types/Makefile

@@ -0,0 +1,14 @@
+.PHONY: publish-patch test
+
+test:
+	npm test
+
+patch: test
+	npm version patch -m "Bump version"
+	git push origin master --tags
+	npm publish
+
+minor: test
+	npm version minor -m "Bump version"
+	git push origin master --tags
+	npm publish

package/node_modules/pg-types/README.md

@@ -0,0 +1,75 @@
+# pg-types
+
+This is the code that turns all the raw text from postgres into JavaScript types for [node-postgres](https://github.com/brianc/node-postgres.git)
+
+## use
+
+This module is consumed and exported from the root `pg` object of node-postgres.  To access it, do the following:
+
+```js
+var types = require('pg').types
+```
+
+Generally what you'll want to do is override how a specific data-type is parsed and turned into a JavaScript type.  By default the PostgreSQL backend server returns everything as strings.  Every data type corresponds to a unique `OID` within the server, and these `OIDs` are sent back with the query response.  So, you need to match a particluar `OID` to a function you'd like to use to take the raw text input and produce a valid JavaScript object as a result. `null` values are never parsed.
+
+Let's do something I commonly like to do on projects: return 64-bit integers `(int8)` as JavaScript integers.  Because JavaScript doesn't have support for 64-bit integers node-postgres cannot confidently parse `int8` data type results as numbers because if you have a _huge_ number it will overflow and the result you'd get back from node-postgres would not be the result in the datbase.  That would be a __very bad thing__ so node-postgres just returns `int8` results as strings and leaves the parsing up to you.  Let's say that you know you don't and wont ever have numbers greater than `int4` in your database, but you're tired of recieving results from the `COUNT(*)` function as strings (because that function returns `int8`).  You would do this:
+
+```js
+var types = require('pg').types
+types.setTypeParser(20, function(val) {
+  return parseInt(val)
+})
+```
+
+__boom__: now you get numbers instead of strings.
+
+Just as another example -- not saying this is a good idea -- let's say you want to return all dates from your database as [moment](http://momentjs.com/docs/) objects.  Okay, do this:
+
+```js
+var types = require('pg').types
+var moment = require('moment')
+var parseFn = function(val) {
+   return val === null ? null : moment(val)
+}
+types.setTypeParser(types.builtins.TIMESTAMPTZ, parseFn)
+types.setTypeParser(types.builtins.TIMESTAMP, parseFn)
+```
+_note: I've never done that with my dates, and I'm not 100% sure moment can parse all the date strings returned from postgres.  It's just an example!_
+
+If you're thinking "gee, this seems pretty handy, but how can I get a list of all the OIDs in the database and what they correspond to?!?!?!" worry not:
+
+```bash
+$ psql -c "select typname, oid, typarray from pg_type order by oid"
+```
+
+If you want to find out the OID of a specific type:
+
+```bash
+$ psql -c "select typname, oid, typarray from pg_type where typname = 'daterange' order by oid"
+```
+
+:smile:
+
+## license
+
+The MIT License (MIT)
+
+Copyright (c) 2014 Brian M. Carlson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/node_modules/pg-types/index.d.ts

@@ -0,0 +1,137 @@
+export enum TypeId {
+    BOOL = 16,
+    BYTEA = 17,
+    CHAR = 18,
+    INT8 = 20,
+    INT2 = 21,
+    INT4 = 23,
+    REGPROC = 24,
+    TEXT = 25,
+    OID = 26,
+    TID = 27,
+    XID = 28,
+    CID = 29,
+    JSON = 114,
+    XML = 142,
+    PG_NODE_TREE = 194,
+    SMGR = 210,
+    PATH = 602,
+    POLYGON = 604,
+    CIDR = 650,
+    FLOAT4 = 700,
+    FLOAT8 = 701,
+    ABSTIME = 702,
+    RELTIME = 703,
+    TINTERVAL = 704,
+    CIRCLE = 718,
+    MACADDR8 = 774,
+    MONEY = 790,
+    MACADDR = 829,
+    INET = 869,
+    ACLITEM = 1033,
+    BPCHAR = 1042,
+    VARCHAR = 1043,
+    DATE = 1082,
+    TIME = 1083,
+    TIMESTAMP = 1114,
+    TIMESTAMPTZ = 1184,
+    INTERVAL = 1186,
+    TIMETZ = 1266,
+    BIT = 1560,
+    VARBIT = 1562,
+    NUMERIC = 1700,
+    REFCURSOR = 1790,
+    REGPROCEDURE = 2202,
+    REGOPER = 2203,
+    REGOPERATOR = 2204,
+    REGCLASS = 2205,
+    REGTYPE = 2206,
+    UUID = 2950,
+    TXID_SNAPSHOT = 2970,
+    PG_LSN = 3220,
+    PG_NDISTINCT = 3361,
+    PG_DEPENDENCIES = 3402,
+    TSVECTOR = 3614,
+    TSQUERY = 3615,
+    GTSVECTOR = 3642,
+    REGCONFIG = 3734,
+    REGDICTIONARY = 3769,
+    JSONB = 3802,
+    REGNAMESPACE = 4089,
+    REGROLE = 4096
+}
+
+export type builtinsTypes =
+    'BOOL' |
+    'BYTEA' |
+    'CHAR' |
+    'INT8' |
+    'INT2' |
+    'INT4' |
+    'REGPROC' |
+    'TEXT' |
+    'OID' |
+    'TID' |
+    'XID' |
+    'CID' |
+    'JSON' |
+    'XML' |
+    'PG_NODE_TREE' |
+    'SMGR' |
+    'PATH' |
+    'POLYGON' |
+    'CIDR' |
+    'FLOAT4' |
+    'FLOAT8' |
+    'ABSTIME' |
+    'RELTIME' |
+    'TINTERVAL' |
+    'CIRCLE' |
+    'MACADDR8' |
+    'MONEY' |
+    'MACADDR' |
+    'INET' |
+    'ACLITEM' |
+    'BPCHAR' |
+    'VARCHAR' |
+    'DATE' |
+    'TIME' |
+    'TIMESTAMP' |
+    'TIMESTAMPTZ' |
+    'INTERVAL' |
+    'TIMETZ' |
+    'BIT' |
+    'VARBIT' |
+    'NUMERIC' |
+    'REFCURSOR' |
+    'REGPROCEDURE' |
+    'REGOPER' |
+    'REGOPERATOR' |
+    'REGCLASS' |
+    'REGTYPE' |
+    'UUID' |
+    'TXID_SNAPSHOT' |
+    'PG_LSN' |
+    'PG_NDISTINCT' |
+    'PG_DEPENDENCIES' |
+    'TSVECTOR' |
+    'TSQUERY' |
+    'GTSVECTOR' |
+    'REGCONFIG' |
+    'REGDICTIONARY' |
+    'JSONB' |
+    'REGNAMESPACE' |
+    'REGROLE';
+
+export type TypesBuiltins = {[key in builtinsTypes]: TypeId};
+
+export type TypeFormat = 'text' | 'binary';
+
+export const builtins: TypesBuiltins;
+
+export function setTypeParser (id: TypeId, parseFn: ((value: string) => any)): void;
+export function setTypeParser (id: TypeId, format: TypeFormat, parseFn: (value: string) => any): void;
+
+export const getTypeParser: (id: TypeId, format?: TypeFormat) => any
+
+export const arrayParser: (source: string, transform: (entry: any) => any) => any[];

package/node_modules/pg-types/index.js

@@ -0,0 +1,47 @@
+var textParsers = require('./lib/textParsers');
+var binaryParsers = require('./lib/binaryParsers');
+var arrayParser = require('./lib/arrayParser');
+var builtinTypes = require('./lib/builtins');
+
+exports.getTypeParser = getTypeParser;
+exports.setTypeParser = setTypeParser;
+exports.arrayParser = arrayParser;
+exports.builtins = builtinTypes;
+
+var typeParsers = {
+  text: {},
+  binary: {}
+};
+
+//the empty parse function
+function noParse (val) {
+  return String(val);
+};
+
+//returns a function used to convert a specific type (specified by
+//oid) into a result javascript type
+//note: the oid can be obtained via the following sql query:
+//SELECT oid FROM pg_type WHERE typname = 'TYPE_NAME_HERE';
+function getTypeParser (oid, format) {
+  format = format || 'text';
+  if (!typeParsers[format]) {
+    return noParse;
+  }
+  return typeParsers[format][oid] || noParse;
+};
+
+function setTypeParser (oid, format, parseFn) {
+  if(typeof format == 'function') {
+    parseFn = format;
+    format = 'text';
+  }
+  typeParsers[format][oid] = parseFn;
+};
+
+textParsers.init(function(oid, converter) {
+  typeParsers.text[oid] = converter;
+});
+
+binaryParsers.init(function(oid, converter) {
+  typeParsers.binary[oid] = converter;
+});

package/node_modules/pg-types/index.test-d.ts

@@ -0,0 +1,21 @@
+import * as types from '.';
+import { expectType } from 'tsd';
+
+// builtins
+expectType<types.TypesBuiltins>(types.builtins);
+
+// getTypeParser
+const noParse = types.getTypeParser(types.builtins.NUMERIC, 'text');
+const numericParser = types.getTypeParser(types.builtins.NUMERIC, 'binary');
+expectType<string>(noParse('noParse'));
+expectType<number>(numericParser([200, 1, 0, 15]));
+
+// getArrayParser 
+const value = types.arrayParser('{1,2,3}', (num) => parseInt(num));
+expectType<number[]>(value);
+
+//setTypeParser
+types.setTypeParser(types.builtins.INT8, parseInt);
+types.setTypeParser(types.builtins.FLOAT8, parseFloat);
+types.setTypeParser(types.builtins.FLOAT8, 'binary', (data) => data[0]);
+types.setTypeParser(types.builtins.FLOAT8, 'text', parseFloat);

package/node_modules/pg-types/lib/arrayParser.js

@@ -0,0 +1,11 @@
+var array = require('postgres-array');
+
+module.exports = {
+  create: function (source, transform) {
+    return {
+      parse: function() {
+        return array.parse(source, transform);
+      }
+    };
+  }
+};