joist-orm 2.3.0-next.41 → 2.3.0-next.43

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "joist-orm",
-  "version": "2.3.0-next.41",
+  "version": "2.3.0-next.43",
   "license": "MIT",
+  "type": "module",
   "repository": {
     "type": "git",
     "url": "https://github.com/joist-orm/joist-orm.git",
@@ -10,68 +11,189 @@
   "engines": {
     "node": "^12.17.0 || ^13.10.0 || ^14 || >= 16.0.0 < 16.2.0 || >= 16.3.0"
   },
-  "main": "build/index.js",
-  "types": "build/index.d.ts",
+  "main": "build/index.cjs",
+  "module": "build/index.js",
+  "types": "build/index.d.mts",
   "typesVersions": {
     "*": {
       "pg": [
-        "build/pg-export.d.ts"
+        "build/pg-export.d.mts"
       ],
       "codegen": [
-        "build/codegen.d.ts"
+        "build/codegen.d.mts"
       ],
       "pg-migrate": [
-        "build/pg-migrate.d.ts"
+        "build/pg-migrate.d.mts"
       ],
       "graphql": [
-        "build/graphql-export.d.ts"
+        "build/graphql-export.d.mts"
       ],
       "graphql-codegen": [
-        "build/graphql-codegen-export.d.ts"
+        "build/graphql-codegen-export.d.mts"
       ],
       "tests": [
-        "build/tests-export.d.ts"
+        "build/tests-export.d.mts"
       ],
       "knex": [
-        "build/knex-export.d.ts"
+        "build/knex-export.d.mts"
       ]
     }
   },
   "bin": {
-    "joist-codegen": "./build/codegen.js",
-    "joist-pg-migrate": "./build/pg-migrate.js"
+    "joist-codegen": "./build/codegen.cjs",
+    "joist-pg-migrate": "./build/pg-migrate.cjs"
   },
   "exports": {
     ".": {
-      "types": "./build/index.d.ts",
+      "bun": {
+        "types": "./build/index.d.mts",
+        "default": "./build/index.js"
+      },
+      "module-sync": {
+        "types": "./build/index.d.mts",
+        "default": "./build/index.js"
+      },
+      "import": {
+        "types": "./build/index.d.mts",
+        "default": "./build/index.js"
+      },
+      "require": {
+        "types": "./build/index.d.cts",
+        "default": "./build/index.cjs"
+      },
       "default": "./build/index.js"
     },
     "./codegen": {
-      "types": "./build/codegen.d.ts",
+      "bun": {
+        "types": "./build/codegen.d.mts",
+        "default": "./build/codegen.js"
+      },
+      "module-sync": {
+        "types": "./build/codegen.d.mts",
+        "default": "./build/codegen.js"
+      },
+      "import": {
+        "types": "./build/codegen.d.mts",
+        "default": "./build/codegen.js"
+      },
+      "require": {
+        "types": "./build/codegen.d.cts",
+        "default": "./build/codegen.cjs"
+      },
       "default": "./build/codegen.js"
     },
     "./pg-migrate": {
-      "types": "./build/pg-migrate.d.ts",
+      "bun": {
+        "types": "./build/pg-migrate.d.mts",
+        "default": "./build/pg-migrate.js"
+      },
+      "module-sync": {
+        "types": "./build/pg-migrate.d.mts",
+        "default": "./build/pg-migrate.js"
+      },
+      "import": {
+        "types": "./build/pg-migrate.d.mts",
+        "default": "./build/pg-migrate.js"
+      },
+      "require": {
+        "types": "./build/pg-migrate.d.cts",
+        "default": "./build/pg-migrate.cjs"
+      },
       "default": "./build/pg-migrate.js"
     },
     "./graphql": {
-      "types": "./build/graphql-export.d.ts",
+      "bun": {
+        "types": "./build/graphql-export.d.mts",
+        "default": "./build/graphql-export.js"
+      },
+      "module-sync": {
+        "types": "./build/graphql-export.d.mts",
+        "default": "./build/graphql-export.js"
+      },
+      "import": {
+        "types": "./build/graphql-export.d.mts",
+        "default": "./build/graphql-export.js"
+      },
+      "require": {
+        "types": "./build/graphql-export.d.cts",
+        "default": "./build/graphql-export.cjs"
+      },
       "default": "./build/graphql-export.js"
     },
     "./graphql-codegen": {
-      "types": "./build/graphql-codegen-export.d.ts",
+      "bun": {
+        "types": "./build/graphql-codegen-export.d.mts",
+        "default": "./build/graphql-codegen-export.js"
+      },
+      "module-sync": {
+        "types": "./build/graphql-codegen-export.d.mts",
+        "default": "./build/graphql-codegen-export.js"
+      },
+      "import": {
+        "types": "./build/graphql-codegen-export.d.mts",
+        "default": "./build/graphql-codegen-export.js"
+      },
+      "require": {
+        "types": "./build/graphql-codegen-export.d.cts",
+        "default": "./build/graphql-codegen-export.cjs"
+      },
       "default": "./build/graphql-codegen-export.js"
     },
     "./tests": {
-      "types": "./build/tests-export.d.ts",
+      "bun": {
+        "types": "./build/tests-export.d.mts",
+        "default": "./build/tests-export.js"
+      },
+      "module-sync": {
+        "types": "./build/tests-export.d.mts",
+        "default": "./build/tests-export.js"
+      },
+      "import": {
+        "types": "./build/tests-export.d.mts",
+        "default": "./build/tests-export.js"
+      },
+      "require": {
+        "types": "./build/tests-export.d.cts",
+        "default": "./build/tests-export.cjs"
+      },
       "default": "./build/tests-export.js"
     },
     "./knex": {
-      "types": "./build/knex-export.d.ts",
+      "bun": {
+        "types": "./build/knex-export.d.mts",
+        "default": "./build/knex-export.js"
+      },
+      "module-sync": {
+        "types": "./build/knex-export.d.mts",
+        "default": "./build/knex-export.js"
+      },
+      "import": {
+        "types": "./build/knex-export.d.mts",
+        "default": "./build/knex-export.js"
+      },
+      "require": {
+        "types": "./build/knex-export.d.cts",
+        "default": "./build/knex-export.cjs"
+      },
       "default": "./build/knex-export.js"
     },
     "./pg": {
-      "types": "./build/pg-export.d.ts",
+      "bun": {
+        "types": "./build/pg-export.d.mts",
+        "default": "./build/pg-export.js"
+      },
+      "module-sync": {
+        "types": "./build/pg-export.d.mts",
+        "default": "./build/pg-export.js"
+      },
+      "import": {
+        "types": "./build/pg-export.d.mts",
+        "default": "./build/pg-export.js"
+      },
+      "require": {
+        "types": "./build/pg-export.d.cts",
+        "default": "./build/pg-export.cjs"
+      },
       "default": "./build/pg-export.js"
     }
   },
@@ -79,14 +201,14 @@
     "build"
   ],
   "dependencies": {
-    "joist-codegen": "2.3.0-next.41",
-    "joist-core": "2.3.0-next.41",
-    "joist-graphql-codegen": "2.3.0-next.41",
-    "joist-graphql-resolver-utils": "2.3.0-next.41",
-    "joist-knex": "2.3.0-next.41",
-    "joist-migration-utils": "2.3.0-next.41",
-    "joist-test-utils": "2.3.0-next.41",
-    "joist-utils": "2.3.0-next.41"
+    "joist-codegen": "2.3.0-next.43",
+    "joist-core": "2.3.0-next.43",
+    "joist-graphql-codegen": "2.3.0-next.43",
+    "joist-graphql-resolver-utils": "2.3.0-next.43",
+    "joist-knex": "2.3.0-next.43",
+    "joist-migration-utils": "2.3.0-next.43",
+    "joist-test-utils": "2.3.0-next.43",
+    "joist-utils": "2.3.0-next.43"
   },
   "peerDependencies": {
     "knex": "^3.1.0",

package/build/codegen.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export * from "joist-codegen";

package/build/drivers/PostgresDriver.d.ts

@@ -1,73 +0,0 @@
-import { Driver, EntityManager, IdAssigner, JoinRowTodo, ParsedFindQuery, PreloadPlugin, RuntimeConfig, Todo } from "joist-core";
-import pg from "pg";
-export interface PostgresDriverOpts {
-    idAssigner?: IdAssigner;
-    /** Sets a default `PreloadPlugin` for any `EntityManager` that uses this driver. */
-    preloadPlugin?: PreloadPlugin;
-    /** Called after each query is executed, useful for testing/debugging. */
-    onQuery?: (sql: string) => void;
-    /**
-     * Experimental: keeps entity find results as raw wire bytes and decodes each row/column cell
-     * lazily on field access, instead of eagerly materializing POJO rows.
-     *
-     * Applies to unpaginated `em.find`, `em.load`, and o2m/o2o/recursive relation loads against
-     * the pure-JS pg client. Other loaders deliberately stay classic: paginated finds (small
-     * pages, measured neutral), m2m join-table rows (narrow + fully read, where materialized rows
-     * measured faster, and `JoinRows` owns/mutates them), lazy columns, and id/count loaders.
-     *
-     * Lazy queries also request *binary* result format (prototype), decoding int/bool/float/text
-     * cells — and, via the fast paths `setupLatestPgTypes` registers, date/timestamptz cells —
-     * wire-bytes -> value with no intermediate strings; numeric/exotic cells render to pg's
-     * canonical text and reuse the active text parsers for parity. `JOIST_LAZY_BINARY=0`
-     * reverts lazy queries to text-format results. It
-     * uses classic rows when the choice is knowable up-front (patching pg-protocol failed, or the
-     * client is unsupported, i.e. pg-native — both warn once). If a connection turns out
-     * mid-query to use an unpatched pg-protocol copy (a duplicate `pg` install), the query fails
-     * with a descriptive error — a misconfiguration CI builds/smoketests will catch immediately.
-     * Note deferred decoding also defers custom-parser errors from `await em.find` to first field
-     * access. See JS-ROW-STORE-DESIGN.md.
-     */
-    lazyRows?: boolean;
-}
-/**
- * Implements the `Driver` interface for Postgres.
- *
- * This is the canonical driver implementation and leverages several aspects of
- * Postgres for the best performance, i.e.:
- *
- * - Deferred foreign key constraints are used to allow bulk inserting/updating
- * all entities without any topographic sorting/ordering issues.
- *
- * - Sequences are used to bulk-assign + then bulk-insert all entities, to again
- * avoid issues with ordering issues (cannot bulk insert A w/o knowing the id of B).
- *
- * - We use a pg-specific bulk update syntax.
- */
-export declare class PostgresDriver implements Driver<pg.PoolClient> {
-    #private;
-    readonly pool: pg.Pool;
-    readonly lazyRows: boolean;
-    /** Defined only when `lazyRows` is enabled; its presence is the capability signal the EM checks. */
-    readonly executeFindRowData: Driver["executeFindRowData"];
-    constructor(pool: pg.Pool, opts?: PostgresDriverOpts);
-    executeFind(em: EntityManager, parsed: ParsedFindQuery, settings: {
-        limit?: number;
-        offset?: number;
-    }): Promise<any[]>;
-    executeQuery(em: EntityManager, sql: string, bindings: readonly any[]): Promise<any[]>;
-    transaction<T>(em: EntityManager, fn: (txn: pg.PoolClient) => Promise<T>): Promise<T>;
-    assignNewIds(_: EntityManager, todos: Record<string, Todo>): Promise<void>;
-    flush(em: EntityManager, entityTodos: Record<string, Todo>, joinRows: Record<string, JoinRowTodo>): Promise<void>;
-    get defaultPlugins(): {
-        preloadPlugin: PreloadPlugin | undefined;
-    };
-    private getMaybeInTxnClient;
-}
-/**
- * Configures the `pg` driver with the best type parsers.
- *
- * In particular, pg's default `TIMESTAMPTZ` parser is very inefficient, and even just
- * pulling in the latest `pg-types` and installing the fixed parser makes a noticable
- * difference.
- */
-export declare function setupLatestPgTypes(temporal: RuntimeConfig["temporal"]): void;

package/build/drivers/WireRowData.d.ts

@@ -1,107 +0,0 @@
-import { RowData } from "joist-core";
-import pg from "pg";
-/**
- * A lazy wire-row {@link RowData} over raw Postgres `DataRow` payload bytes.
- *
- * Each query produces its own `WireRowData` — one query, one result; results are never combined
- * or appended across queries, and the payload is read-only after the query completes (entity
- * mutations go into `InstanceData.data`, never back into the row bytes).
- *
- * Rows are kept in their row-major wire format (`int16 fieldCount` + length-prefixed cells) as
- * zero-copy views over the parser's own immutable buffers: `addRow` records each DataRow's
- * `(bytes, offset, length)` by reference, deduping the socket chunk that consecutive rows
- * share. (Our pg-protocol patch guarantees message bytes are never rewritten — chunks parse in
- * place and straddling messages get a buffer of their own; see `patchPgProtocol.ts`.) A
- * `row × column` cell is decoded on first field access by scanning the row's length-prefixed
- * cells to the column's ordinal ("row-lazy" decode, see JS-ROW-STORE-DESIGN.md §3/C2). This is
- * deferred decoding of row-major data, not a columnar layout.
- *
- * Because chunks are whole socket reads, retaining any row pins its ~64KiB chunk (plus whatever
- * protocol frames share it); `finalize`'s compaction copies retained rows out into an
- * exact-size owned buffer when enough of the payload was dropped.
- *
- * Text-format cells go through the same active text parsers node-postgres would resolve for
- * the query (i.e. honoring pool/client `TypeOverrides`), so they parse identically to classic
- * rows. Binary-format cells decode via `wireBinaryParser`: wire bytes -> value directly for
- * default-parsed scalar types (no intermediate string), else rendered to pg's canonical text
- * and fed through the active text parser for parity. (Classic node-postgres cannot do binary
- * at all — it round-trips cells through a UTF-8 string, corrupting bytes >= 0x80.)
- *
- * Because decoding is deferred, a custom parser that throws will do so on first field access
- * (or `toRow`/`toRows`), not while awaiting the query; `id` and inheritance-discriminator cells
- * still decode during hydration.
- *
- * After hydration, `finalize` trims unused capacity and, when some rows were not retained (i.e.
- * their entities were already in the identity map), compacts the payload down to only the
- * retained rows, so retained memory tracks live entities rather than query history.
- *
- * Small results deliberately stay lazy — there is NO row-count threshold below which we
- * materialize to a `PojoRowData` instead. Measured (benchmark-rowdata-small.ts, 40-col rows):
- * for the typical sparse access pattern (~6 of 40 columns read), keeping the lazy result wins at
- * every size including a single row (n=1: 4.3µs vs 7.6µs; n=1000: 0.76ms vs 3.0ms), because
- * materialization eagerly decodes every column while lazy faults only what is read. Even full
- * column coverage no longer flips the winner: with binary decode and `#readCell`'s adaptive
- * scan cursor, reading all ~36 columns of every row measures ~parity with classic end-to-end
- * (benchmark-lazy-parsing.ts), and small finds (n <= 10) are statistically identical.
- */
-export declare class WireRowData implements RowData {
-    #private;
-    get rowCount(): number;
-    /** The DataRow payload bytes currently indexed; drops when compaction discards rows. */
-    get payloadBytes(): number;
-    /** The bytes currently held by payload chunks + the row-slice table, i.e. for benchmarks. */
-    get memoryBytes(): number;
-    get(rowIndex: number, columnName: string): any;
-    /** Materializes one row as a POJO, i.e. for debugging and differential tests; values are not cached. */
-    toRow(rowIndex: number): any;
-    /** Materializes classic POJO rows, i.e. for `afterFind` observation or debugging; not cached. */
-    toRows(): any[];
-    /**
-     * Resolves each column's decoder from the query's RowDescription.
-     *
-     * Binary-format fields decode through Joist's own binary registry only (see
-     * `setBinaryTypeParser`) — `pg.types`/`TypeOverrides` are never consulted, and a column whose
-     * oid has no registered binary parser fails the query here, before any rows arrive, rather
-     * than guessing at a lossy decoding. Text-format fields (the `binary: false` escape hatch)
-     * decode by utf8-slicing the cell into the active text parser, resolved via `getTypeParser`
-     * (i.e. the pool/client `TypeOverrides` chain) or the global registry.
-     */
-    setRowDescription(fields: Array<{
-        name: string;
-        dataTypeID: number;
-        format?: string;
-    }>, getTypeParser?: (dataTypeID: number) => (value: any) => any): void;
-    /**
-     * Records one DataRow payload *by reference* (zero-copy); called synchronously from the wire
-     * parser, whose patched buffer management guarantees the bytes are never rewritten.
-     *
-     * Consecutive rows usually share one socket chunk, so `bytes` is deduped against the last
-     * chunk ref; retaining any row of a chunk pins the whole chunk, which `finalize`'s compaction
-     * resolves by copying retained rows out when enough of the payload was dropped.
-     */
-    addRow(bytes: Buffer, offset: number, payloadLength: number): void;
-    /** Marks `rowIndex` as retained by a hydrated entity; unmarked rows can be compacted away. */
-    retain(rowIndex: number): void;
-    /**
-     * Trims unused capacity, and compacts down to only `retain`-ed rows when enough rows were not
-     * retained to be worth the copy.
-     *
-     * Compaction exists to release pinned socket buffers to the GC: rows are zero-copy views into
-     * whole ~64KiB chunks, so keeping any row alive pins its entire chunk — and unretained rows
-     * are typically duplicates whose entities were *already in memory* (identity-map hits that
-     * keep their original `rowData`), making the newly-arrived bytes dead weight. Copying the
-     * retained rows into one exact-size owned buffer lets every chunk reference drop.
-     *
-     * The copy re-copies every retained byte, so it only pays off when it buys back a meaningful
-     * fraction of the payload: we compact when the dropped rows hold more than 20% of the payload
-     * bytes, and otherwise just trim, accepting the (bounded) leftover bytes. Called once after
-     * hydration + sidecar reads (`_tags`, preload aggregates) are complete; retained entities keep
-     * their original `rowIndex`, and un-compacted unretained rows simply remain readable-but-unused.
-     */
-    finalize(): void;
-}
-export declare function executeRowDataQuery(client: pg.PoolClient, sql: string, bindings: readonly any[], opts?: {
-    binary?: boolean;
-}): Promise<RowData>;
-/** Returns whether `client` supports the lazy row-data query path, before submitting anything. */
-export declare function isRowDataCapableClient(client: unknown): client is pg.PoolClient;

package/build/graphql-codegen-export.d.ts

@@ -1 +0,0 @@
-export * from "joist-graphql-codegen";

package/build/graphql-codegen-export.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"graphql-codegen-export.js","sourceRoot":"","sources":["../src/graphql-codegen-export.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,kDAAkD;AAClD,wDAAsC"}

package/build/graphql-export.d.ts

@@ -1 +0,0 @@
-export * from "joist-graphql-resolver-utils";

package/build/graphql-export.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"graphql-export.js","sourceRoot":"","sources":["../src/graphql-export.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,yDAAyD;AACzD,+DAA6C"}

package/build/index.d.ts

@@ -1,3 +0,0 @@
-export * from "joist-core";
-export { type ConnectionConfig, Deferred, groupBy, isPlainObject, keyBy, newPgConnectionConfig } from "joist-utils";
-export type { CallbackFn } from "joist-utils";

package/build/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,uCAAuC;AACvC,6CAA2B;AAE3B,wFAAwF;AACxF,2CAAoH;AAApF,uGAAA,QAAQ,OAAA;AAAE,sGAAA,OAAO,OAAA;AAAE,4GAAA,aAAa,OAAA;AAAE,oGAAA,KAAK,OAAA;AAAE,oHAAA,qBAAqB,OAAA"}

package/build/knex-export.d.ts

@@ -1 +0,0 @@
-export * from "joist-knex";

package/build/knex-export.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"knex-export.js","sourceRoot":"","sources":["../src/knex-export.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,uCAAuC;AACvC,6CAA2B"}

package/build/pg-export.d.ts

@@ -1,3 +0,0 @@
-export { type BinaryParse, binaryArrayParser, binaryTextParser, getBinaryTypeParser, registerDatabaseBinaryParsers, setBinaryTypeParser, setSessionTimeZone, } from "./drivers/binaryParsers.js";
-export { PostgresDriver, PostgresDriverOpts, setupLatestPgTypes } from "./drivers/PostgresDriver.js";
-export { seed } from "./seed.js";

package/build/pg-export.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pg-export.js","sourceRoot":"","sources":["../src/pg-export.ts"],"names":[],"mappings":";;;AAAA,sFAAsF;AACtF,sFAAsF;AACtF,0FAA0F;AAC1F,6BAA6B;AAC7B,+DAQoC;AANlC,qHAAA,iBAAiB,OAAA;AACjB,oHAAA,gBAAgB,OAAA;AAChB,uHAAA,mBAAmB,OAAA;AACnB,iIAAA,6BAA6B,OAAA;AAC7B,uHAAA,mBAAmB,OAAA;AACnB,sHAAA,kBAAkB,OAAA;AAEpB,iEAAqG;AAA5F,mHAAA,cAAc,OAAA;AAAsB,uHAAA,kBAAkB,OAAA;AAC/D,qCAAiC;AAAxB,+FAAA,IAAI,OAAA"}

package/build/pg-migrate.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export * from "joist-migration-utils";

package/build/tests-export.d.ts

@@ -1 +0,0 @@
-export * from "joist-test-utils";

package/build/tests-export.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tests-export.js","sourceRoot":"","sources":["../src/tests-export.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6CAA6C;AAC7C,mDAAiC"}