@lunora/hyperdrive 1.0.0-alpha.18 → 1.0.0-alpha.180

package/dist/index.d.mts

@@ -1,187 +1,81 @@
+import { H as HyperdriveLike, a as HyperdriveConnection, M as Mysql2Like, S as SqlClient, N as NodePgLike, P as PostgresJsLike } from "./packem_shared/types.d-B2JdXSms.mjs";
 /**
-* Public types for `@lunora/hyperdrive`.
-*
-* Hyperdrive points at a database **Lunora does not own**. Everything here is
-* deliberately structural (no hard dependency on `@cloudflare/workers-types` or
-* any SQL driver) so unit tests can pass plain-object doubles, exactly like the
-* `D1DatabaseLike` projection in `@lunora/d1`.
-*
-* The hard constraint, restated wherever this surface is used: Hyperdrive
-* queries are **non-deterministic** (forbidden in `query`/`mutation`, allowed
-* only in `action`s — see the `hyperdrive_outside_action` advisor lint), and
-* external writes are **invisible to Lunora live queries** — a subscription will
-* NOT re-run when an external Postgres/MySQL row changes.
-*/
-/**
-* Structural projection of the Cloudflare `Hyperdrive` binding (`env.HYPERDRIVE`).
-*
-* Mirrors the fields of the real `Hyperdrive` from `@cloudflare/workers-types`
-* but stays structural so a unit test can pass a plain object. At runtime only
-* `connectionString` is needed to construct a driver; the discrete connection
-* parts are surfaced for drivers that prefer a config object over a DSN.
-*/
-interface HyperdriveLike {
-  /** A connection string Hyperdrive routes through its pooled, cached edge connection. */
-  connectionString: string;
-  /** Database name component of the connection. */
-  database: string;
-  /** Host Hyperdrive presents to the driver (the local proxy, not your origin DB). */
-  host: string;
-  /** Password component of the connection. */
-  password: string;
-  /** Port Hyperdrive presents to the driver. */
-  port: number;
-  /** User component of the connection. */
-  user: string;
-}
-/**
-* The connection config surfaced by {@link import("./create-hyperdrive").createHyperdrive | createHyperdrive}: the raw
-* `connectionString` plus the discrete parts, ready to hand to a driver.
-*/
-interface HyperdriveConnection {
-  /** Database name. */
-  database: string;
-  /** Host (Hyperdrive's local proxy). */
-  host: string;
-  /** Password. */
-  password: string;
-  /** Port. */
-  port: number;
-  /** User. */
-  user: string;
-}
-/**
-* The driver-agnostic SQL surface bound to `ctx.sql` on **`ActionCtx` only**.
-*
-* This is the exact type the generated ctx imports as
-* `import("@lunora/hyperdrive").SqlClient`. Keep the name and shape stable — the
-* codegen ctx wiring (Phase 1) depends on it.
-*
-* It is intentionally minimal — a single parameterised `query` — so it maps onto
-* `postgres` (postgres.js), `pg` (node-postgres) and `mysql2` alike via the
-* {@link import("./create-hyperdrive").fromPostgresJs | fromPostgresJs} /
-* {@link import("./create-hyperdrive").fromNodePg | fromNodePg} /
-* {@link import("./create-hyperdrive").fromMysql2 | fromMysql2} adapters. Use
-* positional placeholders that match your driver (`$1, $2` for Postgres, `?` for
-* MySQL); the package does not rewrite SQL.
-*
-* Reminder (also on the emitted JSDoc): non-deterministic, action-only,
-* non-reactive — writes here are not tracked by Lunora live queries.
-*/
-interface SqlClient {
-  /**
-  * Run a parameterised SQL statement and return the result rows.
-  *
-  * SECURITY: `text` is executed verbatim — the package never rewrites or
-  * escapes it. NEVER interpolate untrusted/user input into `text`; put every
-  * value in `params` and reference it with a positional placeholder (`$1`/`?`).
-  * Building `text` by string-concatenating request data is a SQL-injection
-  * sink against your own Postgres/MySQL. Identifiers (table/column names) can't
-  * be parameterised — allowlist them against a fixed set, don't interpolate.
-  * @param text SQL text with driver-native positional placeholders.
-  * @param params Bound parameter values, positionally matched to `text`.
-  * @returns The rows the statement produced (empty for non-`SELECT`s that
-  * return no rows).
-  */
-  query: <Row = Record<string, unknown>>(text: string, params?: ReadonlyArray<unknown>) => Promise<Row[]>;
-}
-/**
-* Structural projection of a `pg` (node-postgres) `Client`/`Pool`. Only the
-* `query` method `fromNodePg` calls is required, kept structural for testing.
-*/
-interface NodePgLike {
-  query: (text: string, params?: ReadonlyArray<unknown>) => Promise<{
-    rows: unknown[];
-  }>;
-}
-/**
-* Structural projection of a `postgres` (postgres.js) tagged-template client.
-* The adapter uses the `.unsafe(text, params)` escape hatch so callers keep
-* full control of the parameter list.
-*/
-interface PostgresJsLike {
-  unsafe: (text: string, params?: ReadonlyArray<unknown>) => Promise<unknown>;
-}
-/**
-* Structural projection of a `mysql2/promise` connection/pool. `mysql2`'s
-* `execute` resolves to a `[rows, fields]` tuple; the adapter takes the first
-* element as the rows.
-*/
-interface Mysql2Like {
-  execute: (text: string, params?: ReadonlyArray<unknown>) => Promise<[unknown, unknown]>;
-}
-/**
-* Surface a Cloudflare Hyperdrive binding as a connection ready to feed a
-* user-supplied SQL driver.
-*
-* `@lunora/hyperdrive` deliberately **bundles no driver** — `postgres`, `pg` and
-* `mysql2` are heavy and the choice is the user's (they are `optional`
-* `peerDependencies`, never `dependencies`). This factory's only job is to lift
-* the binding's connection details out; the user constructs their own driver
-* from `connectionString` and wraps it with one of the {@link fromPostgresJs} /
-* {@link fromNodePg} / {@link fromMysql2} adapters to get a {@link SqlClient}.
-* @example
-* ```ts
-* import { createHyperdrive, fromPostgresJs } from "@lunora/hyperdrive";
-* import postgres from "postgres";
-*
-* // inside an action (never a query/mutation):
-* const { connectionString } = createHyperdrive(env.HYPERDRIVE);
-* ctx.sql = fromPostgresJs(postgres(connectionString));
-* const rows = await ctx.sql.query("select id from users where org = $1", [orgId]);
-* ```
-* @remarks
-* Hyperdrive talks to an **external** database Lunora has no visibility into.
-* Queries through `ctx.sql` are non-deterministic (action-only — enforced by the
-* `hyperdrive_outside_action` advisor lint) and external writes are NOT tracked
-* by Lunora live queries: subscriptions will not re-run when external rows
-* change. Use Hyperdrive to *integrate* an existing DB from an action; if you
-* want that data to be reactive, write a projection of it into a `defineSchema`
-* DO/D1 table.
-* @param binding The `env.HYPERDRIVE` binding (or a structural double).
-* @returns The raw `connectionString` plus the discrete connection parts.
-*/
+ * Surface a Cloudflare Hyperdrive binding as a connection ready to feed a
+ * user-supplied SQL driver.
+ *
+ * `@lunora/hyperdrive` deliberately **bundles no driver** — `postgres`, `pg` and
+ * `mysql2` are heavy and the choice is the user's (they are `optional`
+ * `peerDependencies`, never `dependencies`). This factory's only job is to lift
+ * the binding's connection details out; the user constructs their own driver
+ * from `connectionString` and wraps it with one of the {@link fromPostgresJs} /
+ * {@link fromNodePg} / {@link fromMysql2} adapters to get a {@link SqlClient}.
+ * @example
+ * ```ts
+ * import { createHyperdrive, fromPostgresJs } from "@lunora/hyperdrive";
+ * import postgres from "postgres";
+ *
+ * // Wire the client once, on the app builder — called per shard construction,
+ * // not per request. `ctx.sql` is emitted `readonly`; it is never assigned.
+ * const app = defineApp<Env>()
+ *     .shard((env) => env.SHARD)
+ *     .hyperdrive((env) => fromPostgresJs(postgres(createHyperdrive(env.HYPERDRIVE).connectionString)))
+ *     .build();
+ *
+ * // Then, inside an action (never a query/mutation):
+ * const rows = await ctx.sql.query("select id from users where org = $1", [orgId]);
+ * ```
+ * @remarks
+ * Hyperdrive talks to an **external** database Lunora has no visibility into.
+ * Queries through `ctx.sql` are non-deterministic (action-only — enforced by the
+ * `hyperdrive_outside_action` advisor lint) and external writes are NOT tracked
+ * by Lunora live queries: subscriptions will not re-run when external rows
+ * change. Use Hyperdrive to *integrate* an existing DB from an action; if you
+ * want that data to be reactive, write a projection of it into a `defineSchema`
+ * DO/D1 table.
+ * @param binding The `env.HYPERDRIVE` binding (or a structural double).
+ * @returns The raw `connectionString` plus the discrete connection parts.
+ */
 declare const createHyperdrive: (binding: HyperdriveLike) => {
   config: HyperdriveConnection;
   connectionString: string;
 };
 /**
-* Wrap a `postgres` (postgres.js) client as a {@link SqlClient}.
-*
-* Uses the driver's `.unsafe(text, params)` escape hatch so the caller supplies
-* a plain SQL string with `$1, $2, …` placeholders and a positional params
-* array. postgres.js's `.unsafe` resolves to a row array.
-*/
+ * Wrap a `postgres` (postgres.js) client as a {@link SqlClient}.
+ *
+ * Uses the driver's `.unsafe(text, params)` escape hatch so the caller supplies
+ * a plain SQL string with `$1, $2, …` placeholders and a positional params
+ * array. postgres.js's `.unsafe` resolves to a row array.
+ */
 declare const fromPostgresJs: (client: PostgresJsLike) => SqlClient;
 /**
-* Wrap a `pg` (node-postgres) `Client` or `Pool` as a {@link SqlClient}.
-*
-* node-postgres returns a result object whose `rows` field holds the row array.
-*/
+ * Wrap a `pg` (node-postgres) `Client` or `Pool` as a {@link SqlClient}.
+ *
+ * node-postgres returns a result object whose `rows` field holds the row array.
+ */
 declare const fromNodePg: (client: NodePgLike) => SqlClient;
 /**
-* Wrap a `mysql2/promise` connection or pool as a {@link SqlClient}.
-*
-* Use `?` placeholders (MySQL positional syntax). `mysql2`'s `execute` resolves
-* to a `[rows, fields]` tuple; the adapter returns the first element. For a
-* non-`SELECT` (DML), `mysql2` yields a `ResultSetHeader` object rather than a
-* row array, so the adapter normalises that to `[]` — matching the empty-array
-* contract the postgres.js / node-postgres adapters already honour.
-*/
+ * Wrap a `mysql2/promise` connection or pool as a {@link SqlClient}.
+ *
+ * Use `?` placeholders (MySQL positional syntax). `mysql2`'s `execute` resolves
+ * to a `[rows, fields]` tuple; the adapter returns the first element. For a
+ * non-`SELECT` (DML), `mysql2` yields a `ResultSetHeader` object rather than a
+ * row array, so the adapter normalises that to `[]` — matching the empty-array
+ * contract the postgres.js / node-postgres adapters already honour.
+ */
 declare const fromMysql2: (connection: Mysql2Like) => SqlClient;
 /** How an external row maps to a Lunora document. */
 interface ProjectOptions {
   /**
-  * Column whose value becomes the Lunora `_id` (stringified). Defaults to `"id"`.
-  * With no `map`, this column is dropped from the document body (it lives on as
-  * `_id`); with a `map`, the mapper owns the body and `_id` is added from here.
-  */
+   * Column whose value becomes the Lunora `_id` (stringified). Defaults to `"id"`.
+   * With no `map`, this column is dropped from the document body (it lives on as
+   * `_id`); with a `map`, the mapper owns the body and `_id` is added from here.
+   */
   idColumn?: string;
   /**
-  * Transform an external row into the stored document body. Omit for the default:
-  * every selected column except `idColumn` is copied verbatim. The returned object
-  * must not include `_id` — it is set from `idColumn`.
-  */
+   * Transform an external row into the stored document body. Omit for the default:
+   * every selected column except `idColumn` is copied verbatim. The returned object
+   * must not include `_id` — it is set from `idColumn`.
+   */
   map?: (row: Record<string, unknown>) => Record<string, unknown>;
 }
 /** Options for {@link pullSourceRows}: the parameterised tenant query plus the row projection. */
@@ -192,20 +86,68 @@ interface PullSourceOptions extends ProjectOptions {
   query: string;
 }
 /**
-* Project one external row to a Lunora document: lift `idColumn` to a stringified
-* `_id`, then either apply `map` or copy every other column verbatim. Throws when
-* the id column is missing/nullish so a misconfigured query fails loudly rather than
-* materializing rows under an `"undefined"` id.
-*
-* Delegates to `@lunora/do`'s `liftSourceId` — the single id-lift the declarative
-* `.source()` poll loop also uses — so the manual bridge and the codegen path can
-* never diverge in their missing-id handling.
-*/
+ * Project one external row to a Lunora document: lift `idColumn` to a stringified
+ * `_id`, then either apply `map` or copy every other column verbatim. Throws when
+ * the id column is missing/nullish so a misconfigured query fails loudly rather than
+ * materializing rows under an `"undefined"` id.
+ *
+ * Delegates to `@lunora/shard-engine`'s `liftSourceId` — the single id-lift the declarative
+ * `.source()` poll loop also uses — so the manual bridge and the codegen path can
+ * never diverge in their missing-id handling.
+ */
 declare const projectSourceRow: (row: Record<string, unknown>, options?: ProjectOptions) => Record<string, unknown>;
 /**
-* Run a parameterised tenant query against Hyperdrive and project every row to a
-* Lunora document ready to hand to `materializeExternalRows`. Call this inside an
-* **action** (where `ctx.sql` lives); pass the result to a mutation for the write.
-*/
+ * Run a parameterised tenant query against Hyperdrive and project every row to a
+ * Lunora document ready to hand to `materializeExternalRows`. Call this inside an
+ * **action** (where `ctx.sql` lives); pass the result to a mutation for the write.
+ */
 declare const pullSourceRows: (sql: SqlClient, options: PullSourceOptions) => Promise<Record<string, unknown>[]>;
-export { type HyperdriveConnection, type HyperdriveLike, type Mysql2Like, type NodePgLike, type PostgresJsLike, type ProjectOptions, type PullSourceOptions, type SqlClient, createHyperdrive, fromMysql2, fromNodePg, fromPostgresJs, projectSourceRow, pullSourceRows };
+export { type HyperdriveConnection, type HyperdriveLike, type Mysql2Like, type NodePgLike, type PostgresJsLike, type ProjectOptions, type PullSourceOptions, type SqlClient,
+/**
+ * `@lunora/hyperdrive` — bring-your-own Postgres/MySQL for Lunora via Cloudflare
+ * Hyperdrive.
+ *
+ * Surfaces a Hyperdrive binding's connection string and a driver-agnostic
+ * {@link import("./types").SqlClient | SqlClient} bound to `ctx.sql` on
+ * **`ActionCtx` only**. External SQL is non-deterministic (action-only) and
+ * non-reactive (live queries do not track external writes) — integrate an
+ * existing DB, do not replace the Lunora data layer. See the README and
+ * {@link import("./create-hyperdrive").createHyperdrive | createHyperdrive} JSDoc.
+ */
+createHyperdrive,
+/**
+ * `@lunora/hyperdrive` — bring-your-own Postgres/MySQL for Lunora via Cloudflare
+ * Hyperdrive.
+ *
+ * Surfaces a Hyperdrive binding's connection string and a driver-agnostic
+ * {@link import("./types").SqlClient | SqlClient} bound to `ctx.sql` on
+ * **`ActionCtx` only**. External SQL is non-deterministic (action-only) and
+ * non-reactive (live queries do not track external writes) — integrate an
+ * existing DB, do not replace the Lunora data layer. See the README and
+ * {@link import("./create-hyperdrive").createHyperdrive | createHyperdrive} JSDoc.
+ */
+fromMysql2,
+/**
+ * `@lunora/hyperdrive` — bring-your-own Postgres/MySQL for Lunora via Cloudflare
+ * Hyperdrive.
+ *
+ * Surfaces a Hyperdrive binding's connection string and a driver-agnostic
+ * {@link import("./types").SqlClient | SqlClient} bound to `ctx.sql` on
+ * **`ActionCtx` only**. External SQL is non-deterministic (action-only) and
+ * non-reactive (live queries do not track external writes) — integrate an
+ * existing DB, do not replace the Lunora data layer. See the README and
+ * {@link import("./create-hyperdrive").createHyperdrive | createHyperdrive} JSDoc.
+ */
+fromNodePg,
+/**
+ * `@lunora/hyperdrive` — bring-your-own Postgres/MySQL for Lunora via Cloudflare
+ * Hyperdrive.
+ *
+ * Surfaces a Hyperdrive binding's connection string and a driver-agnostic
+ * {@link import("./types").SqlClient | SqlClient} bound to `ctx.sql` on
+ * **`ActionCtx` only**. External SQL is non-deterministic (action-only) and
+ * non-reactive (live queries do not track external writes) — integrate an
+ * existing DB, do not replace the Lunora data layer. See the README and
+ * {@link import("./create-hyperdrive").createHyperdrive | createHyperdrive} JSDoc.
+ */
+fromPostgresJs, projectSourceRow, pullSourceRows };