@crvouga/postgres-mem 0.1.0

package/dist/types/jsonb.d.ts

@@ -0,0 +1,45 @@
+import { type Numeric } from "./numeric.js";
+/**
+ * jsonb value tree. Numbers are kept as `numeric` (PG stores jsonb numbers
+ * as numeric — `1.50::jsonb` keeps its scale). Object keys are unique;
+ * output order is (length, byte order), matching PG jsonb.
+ */
+export type JsonbValue = {
+    j: "null";
+} | {
+    j: "bool";
+    v: boolean;
+} | {
+    j: "num";
+    v: Numeric;
+} | {
+    j: "str";
+    v: string;
+} | {
+    j: "arr";
+    v: JsonbValue[];
+} | {
+    j: "obj";
+    v: Map<string, JsonbValue>;
+};
+export declare const JSONB_NULL: JsonbValue;
+export declare function jsonbBool(v: boolean): JsonbValue;
+export declare function jsonbNum(v: Numeric): JsonbValue;
+export declare function jsonbStr(v: string): JsonbValue;
+export declare function jsonbArr(v: JsonbValue[]): JsonbValue;
+export declare function jsonbObj(entries: Iterable<[string, JsonbValue]>): JsonbValue;
+export declare function parseJsonText(text: string): JsonbValue;
+/** Validate json text without canonicalizing (for `json` type input). */
+export declare function validateJsonText(text: string): void;
+/** jsonb key sort: length first, then byte order (PG lexCompareJsonbStringValue). */
+export declare function jsonbKeyCompare(a: string, b: string): number;
+/** Render jsonb in PG's canonical text form: `{"a": 1, "b": [1, 2]}` */
+export declare function jsonbText(v: JsonbValue): string;
+/** Render as compact json text with insertion order (row_to_json / to_json / composite_to_json). */
+export declare function jsonbCompactText(v: JsonbValue): string;
+/** Structural equality (jsonb = jsonb). */
+export declare function jsonbEquals(a: JsonbValue, b: JsonbValue): boolean;
+/** Total order over jsonb (matches jsonb btree comparison semantics). */
+export declare function jsonbCompare(a: JsonbValue, b: JsonbValue): number;
+/** jsonb containment (@>). */
+export declare function jsonbContains(a: JsonbValue, b: JsonbValue): boolean;

package/dist/types/numeric.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Arbitrary-precision decimal mirroring PostgreSQL's `numeric`.
+ *
+ * Value = (nan/inf special) or coefficient * 10^-dscale where `coef` is a
+ * signed bigint and `dscale` (display scale) is the number of digits after
+ * the decimal point. Display scale is significant: `2.50` renders as "2.50".
+ */
+export interface Numeric {
+    readonly kind: "numeric";
+    /** signed coefficient; value = coef * 10^-dscale */
+    readonly coef: bigint;
+    /** display scale (digits after decimal point), >= 0 */
+    readonly dscale: number;
+    readonly special: "nan" | "inf" | "-inf" | null;
+}
+export declare function makeNumeric(coef: bigint, dscale: number): Numeric;
+export declare const NUMERIC_NAN: Numeric;
+export declare const NUMERIC_PINF: Numeric;
+export declare const NUMERIC_NINF: Numeric;
+export declare function isNumeric(v: unknown): v is Numeric;
+export declare function numericFromBigInt(v: bigint): Numeric;
+export declare function numericFromNumber(v: number): Numeric;
+/** Parse text into numeric. Throws 22P02 on bad syntax (like numeric_in). */
+export declare function parseNumeric(text: string): Numeric;
+export declare function numericRescale(v: Numeric, dscale: number): Numeric;
+export declare function numericText(v: Numeric): string;
+export declare function numericIsZero(v: Numeric): boolean;
+export declare function numericSign(v: Numeric): number;
+/** Compare (NaN sorts greater than everything, like PG). Returns -1|0|1. */
+export declare function numericCmp(a: Numeric, b: Numeric): number;
+export declare function numericAdd(a: Numeric, b: Numeric): Numeric;
+export declare function numericNeg(a: Numeric): Numeric;
+export declare function numericSub(a: Numeric, b: Numeric): Numeric;
+export declare function numericMul(a: Numeric, b: Numeric): Numeric;
+/** Result scale for division, mirroring numeric.c select_div_scale. */
+export declare function selectDivScale(a: Numeric, b: Numeric): number;
+/** Divide with explicit result scale, rounding half away from zero. */
+export declare function numericDivScaled(a: Numeric, b: Numeric, rscale: number): Numeric;
+export declare function numericDiv(a: Numeric, b: Numeric): Numeric;
+/** Truncated integer division (div(a,b) function semantics). */
+export declare function numericDivTrunc(a: Numeric, b: Numeric): Numeric;
+/** Modulo like numeric_mod: result has scale max(s1, s2), sign of dividend. */
+export declare function numericMod(a: Numeric, b: Numeric): Numeric;
+export declare function numericAbs(a: Numeric): Numeric;
+/** round(v, s): round half away from zero; result dscale = max(s, 0). */
+export declare function numericRound(a: Numeric, s: number): Numeric;
+/** trunc(v, s): truncate toward zero. */
+export declare function numericTrunc(a: Numeric, s: number): Numeric;
+export declare function numericFloor(a: Numeric): Numeric;
+export declare function numericCeil(a: Numeric): Numeric;
+export declare function numericToNumber(a: Numeric): number;
+/** Exact bigint if integral after rounding to scale 0 (half away from zero). */
+export declare function numericToBigInt(a: Numeric): bigint;
+/** sqrt via integer Newton iteration at extended scale. */
+export declare function numericSqrt(a: Numeric): Numeric;
+/** power for numeric with numeric result: ports PG's power_var/power_var_int in fixed point. */
+export declare function numericPower(a: Numeric, b: Numeric): Numeric;
+/** exp(numeric) in fixed point with PG's exp_var display-scale rule. */
+export declare function numericExp(a: Numeric): Numeric;
+/** ln(numeric) in fixed point with PG's numeric_ln display-scale rule. */
+export declare function numericLn(a: Numeric): Numeric;
+/** log(base, x) = ln(x)/ln(base) in fixed point with PG's log_var scale rule. */
+export declare function numericLogBase(base: Numeric, x: Numeric): Numeric;
+/** log10(numeric) in fixed point. */
+export declare function numericLog10(a: Numeric): Numeric;
+/** Apply numeric(precision, scale) typmod constraint. */
+export declare function applyNumericTypmod(v: Numeric, precision: number, scale: number): Numeric;
+/** Strip trailing fractional zeros (used by jsonb number canonicalization is NOT this; PG keeps scale). */
+export declare function numericStripTrailingZeros(v: Numeric): Numeric;

package/dist/types/resolve.d.ts

@@ -0,0 +1,15 @@
+import type { TypeName } from "../ast/nodes.js";
+import type { DatabaseState } from "../storage/database-state.js";
+import type { ColumnType } from "./value.js";
+export interface ResolvedType {
+    readonly column: ColumnType;
+    /** "schema.name" when the name resolved to a domain */
+    readonly domain: string | null;
+    /** serial pseudo-types need sequence creation in DDL */
+    readonly serial: "int2" | "int4" | "int8" | null;
+}
+/**
+ * Resolve a parsed type name against the catalog: builtin alias, enum, or
+ * domain (searched along search_path). Throws 42704 when nothing matches.
+ */
+export declare function resolveTypeName(state: DatabaseState, tn: TypeName): ResolvedType;

package/dist/types/timezone.d.ts

@@ -0,0 +1,9 @@
+/** Offset (seconds east of UTC) of `zone` at the given UTC instant. */
+export declare function zoneOffsetAtUtc(zone: string, utcMicros: bigint): number;
+/**
+ * Offset for interpreting a naive local timestamp in `zone`
+ * (two-pass refinement over {@link zoneOffsetAtUtc}).
+ */
+export declare function zoneOffsetForNaive(zone: string, naiveMicros: bigint): number;
+/** Validate a zone string (throws when unrecognized). */
+export declare function validateZone(zone: string): void;

package/dist/types/value.d.ts

@@ -0,0 +1,99 @@
+import { type Interval } from "./datetime.js";
+import { type JsonbValue } from "./jsonb.js";
+import { type Numeric } from "./numeric.js";
+/**
+ * Canonical type ids are lowercase PG internal names: "int4", "text",
+ * "timestamptz", … Arrays are `elem + "[]"`. Enums are `"enum:" + qualified
+ * name`. "unknown" is the type of untyped string literals; "null" never
+ * appears (null datums carry whatever type context provides).
+ */
+export type TypeId = string;
+export type Datum = null | boolean | number | bigint | string | Uint8Array | Numeric | Interval | PgArray | PgRecord | JsonbWrap;
+export interface PgArray {
+    readonly kind: "pgarray";
+    readonly elem: TypeId;
+    /** dimension lengths, outermost first; empty array => [] */
+    readonly dims: number[];
+    /** lower bounds per dimension (default 1) */
+    readonly lbs: number[];
+    /** row-major flattened items */
+    readonly items: Datum[];
+}
+export interface PgRecord {
+    readonly kind: "pgrecord";
+    readonly types: TypeId[];
+    readonly values: Datum[];
+    readonly names?: string[];
+}
+/** jsonb datums are wrapped so `typeof` dispatch stays unambiguous. */
+export interface JsonbWrap {
+    readonly kind: "jsonb";
+    readonly value: JsonbValue;
+}
+export declare function wrapJsonb(value: JsonbValue): JsonbWrap;
+export declare function isJsonbWrap(v: unknown): v is JsonbWrap;
+export declare function isPgArray(v: unknown): v is PgArray;
+export declare function isPgRecord(v: unknown): v is PgRecord;
+export declare function makeArray(elem: TypeId, items: Datum[], dims?: number[], lbs?: number[]): PgArray;
+export interface TypedValue {
+    readonly t: TypeId;
+    readonly v: Datum;
+}
+export declare function tv(t: TypeId, v: Datum): TypedValue;
+export declare const UNKNOWN = "unknown";
+export interface TypeMod {
+    /** varchar(n)/bpchar(n): max chars; numeric: precision; time/timestamp: fractional digits */
+    readonly a?: number;
+    /** numeric scale */
+    readonly b?: number;
+}
+export interface ColumnType {
+    readonly id: TypeId;
+    readonly mod: TypeMod | null;
+}
+export declare function normalizeTypeName(name: string): TypeId | null;
+export declare function isArrayType(t: TypeId): boolean;
+export declare function arrayElemType(t: TypeId): TypeId;
+export declare function arrayTypeOf(elem: TypeId): TypeId;
+export declare function isEnumType(t: TypeId): boolean;
+export declare function enumTypeName(t: TypeId): string;
+/** SQL-facing type name (format_type / pg_typeof style). */
+export declare function typeDisplayName(t: TypeId): string;
+export declare const TYPE_OIDS: Record<string, number>;
+export declare function typeOid(t: TypeId): number;
+export declare function float8Text(v: number): string;
+export declare function float4Text(v: number): string;
+export declare function parseFloatText(text: string, type: "float4" | "float8"): number;
+export declare const INT2_MIN = -32768;
+export declare const INT2_MAX = 32767;
+export declare const INT4_MIN = -2147483648;
+export declare const INT4_MAX = 2147483647;
+export declare const INT8_MIN = -9223372036854775808n;
+export declare const INT8_MAX = 9223372036854775807n;
+export declare function checkInt2(v: number): number;
+export declare function checkInt4(v: number): number;
+export declare function checkInt8(v: bigint): bigint;
+export declare function parseBoolText(text: string): boolean;
+export declare function parseByteaText(text: string): Uint8Array;
+export declare function byteaText(v: Uint8Array): string;
+export declare function parseUuidText(text: string): string;
+export declare function parseMoneyText(text: string): bigint;
+export declare function moneyText(cents: bigint): string;
+export interface OutputCtx {
+    /** offset seconds east of UTC for rendering timestamptz at given UTC micros */
+    zoneOffsetAt(utcMicros: bigint): number;
+}
+export declare const UTC_OUTPUT: OutputCtx;
+export declare function arrayText(arr: PgArray, ctx: OutputCtx): string;
+export declare function recordText(rec: PgRecord, ctx: OutputCtx): string;
+/** Render a non-null datum of type `t` to PG wire text. */
+export declare function datumText(t: TypeId, v: Datum, ctx: OutputCtx): string;
+export interface InputCtx {
+    /** session zone offset lookup for naive timestamptz input */
+    zoneOffsetForNaive(naiveMicros: bigint): number;
+    /** enum label validation: returns true when label is valid for the enum type */
+    enumHasLabel?(enumType: TypeId, label: string): boolean;
+}
+export declare const UTC_INPUT: InputCtx;
+/** Parse PG wire text into a datum of type `t` (typinput). */
+export declare function datumFromText(t: TypeId, text: string, ctx: InputCtx): Datum;

package/dist/unstable.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @packageDocumentation
+ * Unstable internals of `@crvouga/postgres-mem`. Everything exported here is
+ * exempt from semver — pin an exact version if you import from this module.
+ *
+ * @module
+ */
+export { executeStatement, makeEnv } from "./executor/execute.js";
+export { EngineCtx } from "./expressions/context.js";
+export { tokenize } from "./lexer/tokenize.js";
+export { parse, parseSingle } from "./parser/index.js";
+export { type Clock, DEFAULT_NOW, fixedClock, systemClock } from "./runtime/clock.js";
+export { deriveSeed, OsEntropy, Prng } from "./runtime/prng.js";
+export { DatabaseState } from "./storage/database-state.js";
+export { type Datum, datumText, type TypedValue, type TypeId } from "./types/value.js";