@coffre/db 0.14.4 → 0.15.0

package/dist/postgres-platform-node.d.ts

@@ -0,0 +1,14 @@
+import { t as Platform } from "./platform-Y3gICK6n.js";
+//#region src/postgres-js/platform.node.d.ts
+export declare const tcp: Platform['tcp'];
+export declare const startTls: Platform['startTls'];
+export declare const isIP: Platform['isIP'];
+export declare const setImmediate: Platform['setImmediate'];
+export declare const clearImmediate: Platform['clearImmediate'];
+export declare const now: Platform['now'];
+export declare const randomBytes: Platform['randomBytes'];
+export declare const pbkdf2: Platform['pbkdf2'];
+export declare const hmac: Platform['hmac'];
+export declare const sha256: Platform['sha256'];
+export declare const md5: Platform['md5'];
+//#endregion

package/dist/postgres-platform-node.js

@@ -0,0 +1,21 @@
+import net from "node:net";
+import tls from "node:tls";
+import crypto from "node:crypto";
+import { performance } from "node:perf_hooks";
+//#region src/postgres-js/platform.node.ts
+const tcp = (to, connected) => "path" in to ? net.connect(to.path, connected) : net.connect(to.port, to.host, connected);
+const startTls = (socket, options) => tls.connect({
+	...options,
+	socket
+});
+const isIP = (host) => net.isIP(host);
+const setImmediate = (fn) => globalThis.setImmediate(fn);
+const clearImmediate = (handle) => globalThis.clearImmediate(handle);
+const now = () => performance.now();
+const randomBytes = (length) => crypto.randomBytes(length);
+const pbkdf2 = async (password, salt, iterations, length) => crypto.pbkdf2Sync(password, salt, iterations, length, "sha256");
+const hmac = async (key, text) => crypto.createHmac("sha256", key).update(text).digest();
+const sha256 = async (data) => crypto.createHash("sha256").update(data).digest();
+const md5 = async (data) => crypto.createHash("md5").update(data).digest("hex");
+//#endregion
+export { clearImmediate, hmac, isIP, md5, now, pbkdf2, randomBytes, setImmediate, sha256, startTls, tcp };

package/dist/postgres-platform-workerd.d.ts

@@ -0,0 +1,61 @@
+import { t as Platform } from "./platform-Y3gICK6n.js";
+import { EventEmitter } from "node:events";
+//#region src/postgres-js/platform.workerd.d.ts
+/** A socket of `cloudflare:sockets`, what of it this uses. */
+interface RawSocket {
+  readonly readable: ReadableStream<Uint8Array>;
+  readonly writable: WritableStream<Uint8Array>;
+  readonly closed: Promise<void>;
+  close(): Promise<void>;
+  startTls(options: {
+    servername?: string;
+  }): RawSocket;
+}
+/**
+ * A `cloudflare:sockets` socket as an event emitter: `connect` once it can
+ * write, `data` for each chunk read, `error` then `close` when it fails.
+ * With TLS to follow, it reads one chunk alone, the server's answer to the
+ * SSLRequest, so that the reader is free for `startTls`.
+ */
+export declare class WorkerdSocket extends EventEmitter {
+  readyState: string;
+  raw: RawSocket | null;
+  /** Destroyed before `connect` made its socket: closed as soon as it has. */
+  destroyed: boolean;
+  writer: WritableStreamDefaultWriter<Uint8Array> | null;
+  reader: ReadableStreamDefaultReader<Uint8Array> | null;
+  connect(port: number, host: string, tls: boolean): Promise<void>;
+  /** Upgraded to TLS, the same emitter: `secureConnect` once the plain socket under it closes. */
+  upgrade(servername: string | undefined): this;
+  write(data: Uint8Array, callback?: () => void): boolean;
+  end(data?: Uint8Array): unknown;
+  /**
+   * Closed at once, as Node's `destroy`, whatever it is still writing or opening: its writes aborted and its reads
+   * cancelled, so that nothing buffered is sent, then the raw socket closed, which on its own waits until the socket
+   * has opened and every write has gone (workerd's `Socket::close`). Upstream ended it, which waits for a write stuck
+   * under backpressure too (reviews r2 and r3 of #438). Its TCP connection workerd closes with the request, whose I/O
+   * it is: locally, not before (packages/vault/test/workers-socket.test.ts). Before `connect` has made the raw socket,
+   * it is made only to be closed. Says `close` once, a task later, as Node's does.
+   */
+  destroy(): void;
+  /** The raw socket's streams torn down, then the socket closed (`destroy`). */
+  abort(): void;
+  read(): Promise<void>;
+  /** The server's answer to the SSLRequest; failed, or the socket closed or destroyed first, said as any read's end. */
+  readFirst(): Promise<void>;
+  close(): void;
+  /** Said once: past `close` (a `destroy`'s, whose aborted streams fail what was under way), nothing more. */
+  error(error: unknown): void;
+}
+export declare const tcp: Platform['tcp'];
+export declare const startTls: Platform['startTls'];
+export declare const isIP: Platform['isIP'];
+export declare const setImmediate: Platform['setImmediate'];
+export declare const clearImmediate: Platform['clearImmediate'];
+export declare const now: Platform['now'];
+export declare const randomBytes: Platform['randomBytes'];
+export declare const pbkdf2: Platform['pbkdf2'];
+export declare const hmac: Platform['hmac'];
+export declare const sha256: Platform['sha256'];
+export declare const md5: Platform['md5'];
+//#endregion

package/dist/postgres-platform-workerd.js

@@ -0,0 +1,163 @@
+import { Buffer } from "node:buffer";
+import { EventEmitter } from "node:events";
+//#region src/postgres-js/platform.workerd.ts
+const v4Seg = "(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])";
+const v4Str = `(${v4Seg}[.]){3}${v4Seg}`;
+const IPv4Reg = new RegExp(`^${v4Str}$`);
+const v6Seg = "(?:[0-9a-fA-F]{1,4})";
+const IPv6Reg = new RegExp(`^((?:${v6Seg}:){7}(?:${v6Seg}|:)|(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|(?:${v6Seg}:){5}(?::${v4Str}|(:${v6Seg}){1,2}|:)|(?:${v6Seg}:){4}(?:(:${v6Seg}){0,1}:${v4Str}|(:${v6Seg}){1,3}|:)|(?:${v6Seg}:){3}(?:(:${v6Seg}){0,2}:${v4Str}|(:${v6Seg}){1,4}|:)|(?:${v6Seg}:){2}(?:(:${v6Seg}){0,3}:${v4Str}|(:${v6Seg}){1,5}|:)|(?:${v6Seg}:){1}(?:(:${v6Seg}){0,4}:${v4Str}|(:${v6Seg}){1,6}|:)|(?::((?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:)))(%[0-9a-zA-Z-.:]{1,})?\$`);
+/**
+* A `cloudflare:sockets` socket as an event emitter: `connect` once it can
+* write, `data` for each chunk read, `error` then `close` when it fails.
+* With TLS to follow, it reads one chunk alone, the server's answer to the
+* SSLRequest, so that the reader is free for `startTls`.
+*/
+var WorkerdSocket = class extends EventEmitter {
+	readyState = "open";
+	raw = null;
+	/** Destroyed before `connect` made its socket: closed as soon as it has. */
+	destroyed = false;
+	writer = null;
+	reader = null;
+	async connect(port, host, tls) {
+		try {
+			this.readyState = "opening";
+			const { connect } = await import("cloudflare:sockets");
+			const raw = this.raw = connect(host + ":" + port, tls ? { secureTransport: "starttls" } : {});
+			if (this.destroyed) return this.abort();
+			raw.closed.then(() => {
+				if (this.readyState !== "upgrade") return this.close();
+				this.readyState = "open";
+				this.emit("secureConnect");
+			}, (error) => this.error(error));
+			this.writer = raw.writable.getWriter();
+			this.reader = raw.readable.getReader();
+			tls ? this.readFirst() : this.read();
+			this.writer.ready.then(() => {
+				this.readyState = "open";
+				this.emit("connect");
+			});
+		} catch (error) {
+			this.error(error);
+		}
+	}
+	/** Upgraded to TLS, the same emitter: `secureConnect` once the plain socket under it closes. */
+	upgrade(servername) {
+		this.writer.releaseLock();
+		this.reader.releaseLock();
+		this.readyState = "upgrading";
+		const raw = this.raw = this.raw.startTls({ servername });
+		raw.closed.then(() => this.close(), (error) => this.error(error));
+		this.writer = raw.writable.getWriter();
+		this.reader = raw.readable.getReader();
+		this.writer.ready.then(() => {
+			this.read();
+			this.readyState = "upgrade";
+		});
+		return this;
+	}
+	write(data, callback) {
+		this.writer.write(data).then(callback, (error) => this.error(error));
+		return true;
+	}
+	end(data) {
+		return data ? this.write(data, () => void this.raw.close()) : this.raw.close();
+	}
+	/**
+	* Closed at once, as Node's `destroy`, whatever it is still writing or opening: its writes aborted and its reads
+	* cancelled, so that nothing buffered is sent, then the raw socket closed, which on its own waits until the socket
+	* has opened and every write has gone (workerd's `Socket::close`). Upstream ended it, which waits for a write stuck
+	* under backpressure too (reviews r2 and r3 of #438). Its TCP connection workerd closes with the request, whose I/O
+	* it is: locally, not before (packages/vault/test/workers-socket.test.ts). Before `connect` has made the raw socket,
+	* it is made only to be closed. Says `close` once, a task later, as Node's does.
+	*/
+	destroy() {
+		if (this.destroyed) return;
+		this.destroyed = true;
+		if (this.raw !== null) this.abort();
+		setTimeout(() => this.close(), 0);
+	}
+	/** The raw socket's streams torn down, then the socket closed (`destroy`). */
+	abort() {
+		const raw = this.raw;
+		(this.writer ?? raw.writable).abort().catch(() => {});
+		(this.reader ?? raw.readable).cancel().catch(() => {});
+		raw.close().catch(() => {});
+	}
+	async read() {
+		try {
+			for (;;) {
+				const { done, value } = await this.reader.read();
+				if (done) return;
+				this.emit("data", Buffer.from(value));
+			}
+		} catch (error) {
+			this.error(error);
+		}
+	}
+	/** The server's answer to the SSLRequest; failed, or the socket closed or destroyed first, said as any read's end. */
+	async readFirst() {
+		try {
+			const { done, value } = await this.reader.read();
+			if (done) return this.close();
+			this.emit("data", Buffer.from(value));
+		} catch (error) {
+			this.error(error);
+		}
+	}
+	close() {
+		if (this.readyState === "closed") return;
+		this.readyState = "closed";
+		this.emit("close");
+	}
+	/** Said once: past `close` (a `destroy`'s, whose aborted streams fail what was under way), nothing more. */
+	error(error) {
+		if (this.readyState === "closed" || this.destroyed) return;
+		this.emit("error", error);
+		this.close();
+	}
+};
+const tcp = (to, connected) => {
+	if ("path" in to) throw new Error("a Unix socket cannot be reached from workerd");
+	const socket = new WorkerdSocket();
+	socket.once("connect", connected);
+	socket.connect(to.port, to.host, to.tls);
+	return socket;
+};
+const startTls = (socket, { servername }) => socket.upgrade(servername);
+const isIP = (host) => IPv4Reg.test(host) ? 4 : IPv6Reg.test(host) ? 6 : 0;
+let ids = 1;
+const tasks = /* @__PURE__ */ new Set();
+const setImmediate = (fn) => {
+	const id = ids++;
+	tasks.add(id);
+	queueMicrotask(() => {
+		if (tasks.has(id)) {
+			fn();
+			tasks.delete(id);
+		}
+	});
+	return id;
+};
+const clearImmediate = (handle) => {
+	tasks.delete(handle);
+};
+const now = () => performance.now();
+const randomBytes = (length) => crypto.getRandomValues(Buffer.alloc(length));
+const encoder = new TextEncoder();
+/** `x`, as WebCrypto types the bytes it takes: a Buffer's memory is never shared. */
+const own = (x) => x;
+const pbkdf2 = async (password, salt, iterations, length) => Buffer.from(await crypto.subtle.deriveBits({
+	name: "PBKDF2",
+	hash: "SHA-256",
+	salt: own(salt),
+	iterations
+}, await crypto.subtle.importKey("raw", encoder.encode(password), "PBKDF2", false, ["deriveBits"]), length * 8));
+const hmac = async (key, text) => Buffer.from(await crypto.subtle.sign("HMAC", await crypto.subtle.importKey("raw", own(key), {
+	name: "HMAC",
+	hash: "SHA-256"
+}, false, ["sign"]), encoder.encode(text)));
+const sha256 = async (data) => Buffer.from(await crypto.subtle.digest("SHA-256", own(data)));
+const md5 = async (data) => Buffer.from(await crypto.subtle.digest("MD5", typeof data === "string" ? encoder.encode(data) : own(data))).toString("hex");
+//#endregion
+export { WorkerdSocket, clearImmediate, hmac, isIP, md5, now, pbkdf2, randomBytes, setImmediate, sha256, startTls, tcp };