@crvouga/mockingbird-service-postgres 1.0.0 → 1.2.0

package/dist/wire/protocol.d.ts

@@ -0,0 +1,119 @@
+/**
+ * PostgreSQL frontend/backend protocol 3.0 message framing: the byte codec only, no behavior.
+ * https://www.postgresql.org/docs/18/protocol-message-formats.html
+ */
+export declare const SSL_REQUEST_CODE = 80877103;
+export declare const GSSENC_REQUEST_CODE = 80877104;
+export declare const CANCEL_REQUEST_CODE = 80877102;
+export declare const PROTOCOL_3_0 = 196608;
+/** Growable big-endian byte builder for one or more backend messages. */
+export declare class ByteWriter {
+    private buf;
+    private view;
+    private len;
+    private ensure;
+    u8(value: number): this;
+    i16(value: number): this;
+    i32(value: number): this;
+    bytes(value: Uint8Array): this;
+    /** A NUL-terminated string. */
+    cstring(value: string): this;
+    get length(): number;
+    take(): Uint8Array;
+}
+/** One backend message: type byte, int32 length (including itself), body. */
+export declare const message: (type: string, body: (w: ByteWriter) => void) => Uint8Array;
+export type FieldDescription = {
+    name: string;
+    tableOid?: number;
+    columnAttr?: number;
+    typeOid: number;
+    typeLen: number;
+    typeMod?: number;
+    /** 0 text, 1 binary. */
+    format: 0 | 1;
+};
+export type ErrorFields = {
+    severity?: "ERROR" | "FATAL" | "PANIC" | "WARNING" | "NOTICE";
+    code: string;
+    message: string;
+    detail?: string;
+    hint?: string;
+    position?: number;
+    constraint?: string;
+    table?: string;
+    column?: string;
+    schema?: string;
+};
+export declare const backend: {
+    authenticationOk: () => Uint8Array<ArrayBufferLike>;
+    authenticationSASL: (mechanisms: string[]) => Uint8Array<ArrayBufferLike>;
+    authenticationSASLContinue: (data: string) => Uint8Array<ArrayBufferLike>;
+    authenticationSASLFinal: (data: string) => Uint8Array<ArrayBufferLike>;
+    parameterStatus: (name: string, value: string) => Uint8Array<ArrayBufferLike>;
+    backendKeyData: (pid: number, key: number) => Uint8Array<ArrayBufferLike>;
+    readyForQuery: (status: "I" | "T" | "E") => Uint8Array<ArrayBufferLike>;
+    rowDescription: (fields: FieldDescription[]) => Uint8Array<ArrayBufferLike>;
+    dataRow: (values: (Uint8Array | null)[]) => Uint8Array<ArrayBufferLike>;
+    commandComplete: (tag: string) => Uint8Array<ArrayBufferLike>;
+    emptyQueryResponse: () => Uint8Array<ArrayBufferLike>;
+    errorResponse: (fields: ErrorFields) => Uint8Array<ArrayBufferLike>;
+    noticeResponse: (fields: ErrorFields) => Uint8Array<ArrayBufferLike>;
+    parseComplete: () => Uint8Array<ArrayBufferLike>;
+    bindComplete: () => Uint8Array<ArrayBufferLike>;
+    closeComplete: () => Uint8Array<ArrayBufferLike>;
+    noData: () => Uint8Array<ArrayBufferLike>;
+    portalSuspended: () => Uint8Array<ArrayBufferLike>;
+    parameterDescription: (oids: number[]) => Uint8Array<ArrayBufferLike>;
+    notificationResponse: (pid: number, channel: string, payload: string) => Uint8Array<ArrayBufferLike>;
+    /** The one-byte answers to SSLRequest / GSSENCRequest: no encryption here. */
+    no: () => Uint8Array<ArrayBuffer>;
+};
+/** Sequential reader over one message body. */
+export declare class ByteReader {
+    readonly bytes: Uint8Array;
+    private pos;
+    private readonly view;
+    constructor(bytes: Uint8Array, start?: number);
+    get remaining(): number;
+    u8(): number;
+    i16(): number;
+    i32(): number;
+    take(n: number): Uint8Array;
+    cstring(): string;
+    rest(): Uint8Array;
+}
+export declare class ProtocolError extends Error {
+    constructor(message: string);
+}
+export type FrontendMessage = {
+    kind: "ssl";
+} | {
+    kind: "gssenc";
+} | {
+    kind: "cancel";
+    pid: number;
+    key: number;
+} | {
+    kind: "startup";
+    protocol: number;
+    parameters: Record<string, string>;
+} | {
+    kind: "typed";
+    type: string;
+    body: ByteReader;
+};
+/**
+ * Splits a byte stream into frontend messages. Before the startup message is seen, frames have
+ * no type byte (StartupMessage, SSLRequest, GSSENCRequest, CancelRequest).
+ */
+export declare class FrameParser {
+    private pending;
+    private started;
+    push(chunk: Uint8Array): FrontendMessage[];
+    private next;
+}
+export declare const utf8: {
+    encode: (s: string) => Uint8Array;
+    decode: (b: Uint8Array) => string;
+};

package/dist/wire/scram.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Server side of SCRAM-SHA-256 (RFC 7677) as PostgreSQL speaks it: one round trip after the
+ * client's first message, channel binding declined (`n` or `y`; no TLS here).
+ */
+export declare class ScramServer {
+    private readonly password;
+    private clientFirstBare;
+    private serverFirst;
+    private nonce;
+    private readonly salt;
+    private readonly iterations;
+    constructor(password: string);
+    /** The server-first-message for a client-first-message; null when the client message is malformed. */
+    first(clientFirst: string): string | null;
+    /** The server-final-message (`v=…`) when the client's proof is right; null otherwise. */
+    final(clientFinal: string): string | null;
+}

package/dist/wire/split.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Split a simple-query script into statements at top-level semicolons, the way the server's
+ * lexer would: quoted strings (`'…'`, `E'…'` with backslashes, `"…"`), dollar quoting
+ * (`$tag$…$tag$`), line and (nested) block comments never split. Empty statements are dropped.
+ */
+export declare const splitStatements: (script: string) => string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crvouga/mockingbird-service-postgres",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Pure TypeScript in-memory PostgreSQL implementation with zero WASM/native dependencies",
   "type": "module",
   "license": "MIT",
@@ -22,6 +22,11 @@
       "types": "./dist/unstable.d.ts",
       "import": "./dist/unstable.js",
       "default": "./dist/unstable.js"
+    },
+    "./wire": {
+      "types": "./dist/wire/index.d.ts",
+      "import": "./dist/wire/index.js",
+      "default": "./dist/wire/index.js"
     }
   },
   "files": [
@@ -49,7 +54,7 @@
   },
   "scripts": {
     "build": "bun run scripts/build.ts",
-    "test": "bun test tests/contract tests/fuzz tests/harness",
+    "test": "bun test tests/contract tests/fuzz tests/harness tests/server",
     "test:contract": "bun test tests/contract",
     "test:fuzz": "bun test tests/fuzz",
     "test:pbt": "bun test tests/fuzz",
@@ -87,7 +92,8 @@
     "portability": "bun ../../../scripts/portability.ts",
     "example:react-vite": "cd examples/react-vite && bun install && bun run dev",
     "fc": "clear && bun format && bun check:full",
-    "test:postgres-native": "bun run scripts/run-postgres-native-tests.ts"
+    "test:postgres-native": "bun run scripts/run-postgres-native-tests.ts",
+    "test:server": "bun test tests/server"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.5",
@@ -124,7 +130,11 @@
       "website": "https://www.postgresql.org",
       "docs": "https://www.postgresql.org/docs/current/"
     },
-    "status": "ready"
+    "status": "ready",
+    "entries": {
+      "wire/index": "node",
+      "wire/cli": "node"
+    }
   },
   "trustedDependencies": [
     "@embedded-postgres/darwin-arm64",
@@ -135,5 +145,8 @@
     "@embedded-postgres/linux-ppc64",
     "@embedded-postgres/linux-x64",
     "@embedded-postgres/windows-x64"
-  ]
+  ],
+  "bin": {
+    "mockingbird-postgres": "./dist/wire/cli.js"
+  }
 }