@lunora/d1 1.0.0-alpha.5 → 1.0.0-alpha.50

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { SchemaLike, DatabaseWriterLike } from '@lunora/do';
-import { SqlCtxDbOptions, createSqlCtxDb, SqlCtxExec, readSqlCdcChanges, SqlDialect } from '@lunora/sql-store';
+import { SqlCtxDbOptions, SqlCtxExec, createSqlCtxDb, readSqlCdcChanges, SqlDialect } from '@lunora/sql-store';
 export { type SqlCtxExec as D1Exec, type SqlCtxDbOptions, type SqlCtxExec, createSqlCtxDb } from '@lunora/sql-store';
 import { BatchItem, BatchResponse } from 'drizzle-orm/batch';
 import { DrizzleD1Database } from 'drizzle-orm/d1';
@@ -13,8 +13,10 @@ declare const runD1GlobalTableMigrations: (exec: SqlCtxExec, schema: SchemaLike)
 declare const runD1AggregateMigrations: (exec: SqlCtxExec, schema: SchemaLike) => Promise<void>;
 /** Materialize the `__rank_&lt;index>` companion tables for the schema's rank indexes. */
 declare const runD1RankMigrations: (exec: SqlCtxExec, schema: SchemaLike) => Promise<void>;
-/** Materialize the `__fts_&lt;index>` fts5 shadow tables for the schema's search indexes (no-op without fts5). */
+/** Materialize (and backfill) the `__fts_&lt;index>` fts5 shadow tables for the schema's search indexes. */
 declare const runD1SearchMigrations: (exec: SqlCtxExec, schema: SchemaLike) => Promise<void>;
+/** Index existing rows into every search companion, including the `staged: true` ones migrations leave empty. */
+declare const backfillD1SearchIndexes: (exec: SqlCtxExec, schema: SchemaLike) => Promise<void>;
 /** Create the `__cdc_log` table in D1 (idempotent; only run when CDC is enabled). */
 declare const runD1CdcMigration: (exec: SqlCtxExec) => Promise<void>;
 /** Read changelog entries newer than `sinceSeq` in commit order. */
@@ -42,32 +44,42 @@ interface ImportResult {
   inserted: Record<string, number>;
 }
 /**
-* Return every `.global()` table in the schema, optionally narrowed by an
-* allowlist. Shard-local tables are skipped here — they're handled by the DO
-* helpers — so callers get a clean separation between the two storage planes.
-*/
+ * Return every `.global()` table in the schema, optionally narrowed by an
+ * allowlist. Shard-local tables are skipped here — they're handled by the DO
+ * helpers — so callers get a clean separation between the two storage planes.
+ */
 declare const selectGlobalTables: (schema: SchemaLike, requested?: ReadonlyArray<string>) => string[];
 interface ExportGlobalArgs {
   batchSize?: number;
   tables?: ReadonlyArray<string>;
 }
 /**
-* Yield rows from every requested `.global()` table in batches. Uses
-* `LIMIT ?/OFFSET ?` because D1 globals don't have a stable keyset abstraction
-* here (the writer's `findMany` does, but at the cost of routing through the
-* full validator pipeline; for a snapshot stream a plain offset scan is
-* sufficient and predictable).
-*/
+ * Yield rows from every requested `.global()` table in batches.
+ *
+ * Keyset-paginates on the physical primary key (`id` — every `.global()` table
+ * carries it, see `frameworkColumnDdl`): `WHERE "id" > ? ORDER BY "id" LIMIT ?`,
+ * carrying the last id forward. A plain `LIMIT/OFFSET` scan would be wrong here —
+ * SQLite gives no ordering guarantee for an unordered SELECT and each page is a
+ * separate query, so pages could overlap or skip rows (and any concurrent
+ * insert/delete would shift offsets and silently drop/duplicate rows in the
+ * snapshot). Keyset paging is deterministic under concurrent writes and avoids
+ * O(n^2) OFFSET scans on large tables.
+ *
+ * Tables are provisioned first (idempotent `CREATE … IF NOT EXISTS`): `.global()`
+ * tables are created lazily on first write, so a fresh deployment — or any table
+ * never written — would otherwise abort the stream with a raw `no such table`
+ * instead of exporting it as empty.
+ */
 declare const exportGlobalRows: (exec: SqlCtxExec, schema: SchemaLike, args: ExportGlobalArgs) => AsyncGenerator<ExportRow, void, undefined>;
 interface ImportGlobalArgs {
   /**
-  * Optional direct exec handle to the same D1 database the writer targets.
-  * When supplied, the conflict pre-probe issues a single
-  * `SELECT 1 FROM &lt;table> WHERE id = ? LIMIT 1` against the row's declared
-  * table instead of falling back to `writer.get(id)`, which scans every
-  * global table looking for the id. Strongly recommended for large schemas
-  * — the writer-fallback is O(N tables) per row.
-  */
+   * Optional direct exec handle to the same D1 database the writer targets.
+   * When supplied, the conflict pre-probe issues a single
+   * `SELECT 1 FROM &lt;table> WHERE id = ? LIMIT 1` against the row's declared
+   * table instead of falling back to `writer.get(id)`, which scans every
+   * global table looking for the id. Strongly recommended for large schemas
+   * — the writer-fallback is O(N tables) per row.
+   */
   exec?: D1ExecLike;
   rows: ReadonlyArray<ExportRow>;
   startLine?: number;
@@ -77,20 +89,19 @@ interface D1ExecLike {
   all: (sql: string, parameters: ReadonlyArray<unknown>) => Promise<Record<string, unknown>[]>;
 }
 /**
-* Import rows into `.global()` tables via the schema-aware D1 writer. The
-* writer rejects unknown ids on `insert` (the writer assigns one when `_id` is
-* absent); we pre-probe each row's `_id` so a collision is reported as a
-* conflict instead of bubbled as a UNIQUE error. Schema-failed rows surface in
-* `errors`; the rest land.
-*/
+ * Import rows into `.global()` tables via the schema-aware D1 writer. The
+ * writer rejects unknown ids on `insert` (the writer assigns one when `_id` is
+ * absent); we pre-probe each row's `_id` so a collision is reported as a
+ * conflict instead of bubbled as a UNIQUE error. Schema-failed rows surface in
+ * `errors`; the rest land.
+ */
 declare const importGlobalRows: (writer: DatabaseWriterLike, schema: SchemaLike, args: ImportGlobalArgs) => Promise<ImportResult>;
 /**
-* Minimal structural projection of `D1Database` to keep the adapter
-* compatible with the real workers-types value as well as unit-test doubles.
-*/
+ * Minimal structural projection of `D1Database` to keep the adapter
+ * compatible with the real workers-types value as well as unit-test doubles.
+ */
 interface D1DatabaseLike {
   batch?: (statements: D1PreparedStatementLike[]) => Promise<unknown[]>;
-  exec?: (sql: string) => Promise<unknown>;
   prepare: (sql: string) => D1PreparedStatementLike;
   withSession: (bookmark?: string) => D1SessionLike;
 }
@@ -131,67 +142,67 @@ declare class D1Session {
   }>;
   first<T = unknown>(sql: string, ...binds: unknown[]): Promise<T | null>;
   /**
-  * Returns the most recent bookmark known to the session, or `undefined`
-  * when D1 has not issued one yet.
-  */
+   * Returns the most recent bookmark known to the session, or `undefined`
+   * when D1 has not issued one yet.
+   */
   getBookmark(): string | undefined;
 }
 declare class D1Client {
   private readonly db;
   /**
-  * SQL string -> prepared statement. Prepared statements are reusable in
-  * D1; preparing the same SQL twice forces the worker to round-trip the
-  * statement plan. Caching is per-instance so unit-test isolation holds.
-  * Bounded to {@link STMT_CACHE_CAPACITY} via LRU eviction.
-  */
+   * SQL string -> prepared statement. Prepared statements are reusable in
+   * D1; preparing the same SQL twice forces the worker to round-trip the
+   * statement plan. Caching is per-instance so unit-test isolation holds.
+   * Bounded to {@link STMT_CACHE_CAPACITY} via LRU eviction.
+   */
   private readonly stmtCache;
   /**
-  * Lazily-built drizzle handle over the bare binding. Memoised so a single
-  * `D1Client` reuses the same dialect/session machinery across calls.
-  */
+   * Lazily-built drizzle handle over the bare binding. Memoised so a single
+   * `D1Client` reuses the same dialect/session machinery across calls.
+   */
   private drizzleHandle;
   constructor(database: D1DatabaseLike);
   /**
-  * Open a Sessions-API scoped session. Pass the bookmark forwarded by
-  * the client to opt into read-your-writes consistency.
-  *
-  * With no bookmark this is the first request of a session — there is no
-  * prior write to read, so we open with the explicit `"first-unconstrained"`
-  * constraint (Cloudflare's lowest-latency default: the first read may serve
-  * from any replica). Read-your-writes for sequenced requests still flows
-  * through the forwarded bookmark; a caller needing a strongly-consistent
-  * very-first read should pass `"first-primary"` as the bookmark instead.
-  */
+   * Open a Sessions-API scoped session. Pass the bookmark forwarded by
+   * the client to opt into read-your-writes consistency.
+   *
+   * With no bookmark this is the first request of a session — there is no
+   * prior write to read, so we open with the explicit `"first-unconstrained"`
+   * constraint (Cloudflare's lowest-latency default: the first read may serve
+   * from any replica). Read-your-writes for sequenced requests still flows
+   * through the forwarded bookmark; a caller needing a strongly-consistent
+   * very-first read should pass `"first-primary"` as the bookmark instead.
+   */
   withSession(bookmark?: string): D1Session;
   /**
-  * Prepare a statement, reusing a cached one when the SQL text matches.
-  * `bind()` on a prepared statement returns a new bound statement and
-  * leaves the underlying prepared plan reusable, so cache hits are safe
-  * even when the previous caller already called `.bind(...).run()`.
-  */
+   * Prepare a statement, reusing a cached one when the SQL text matches.
+   * `bind()` on a prepared statement returns a new bound statement and
+   * leaves the underlying prepared plan reusable, so cache hits are safe
+   * even when the previous caller already called `.bind(...).run()`.
+   */
   prepare(sql: string): D1PreparedStatementLike;
   /**
-  * Drizzle handle over the bare `env.DB` binding. Used for typed queries
-  * against generated `sqliteTable` schemas; does **not** participate in the
-  * D1 Sessions API (no bookmark pinning). For bookmark-scoped reads, use
-  * {@link drizzleSession} instead.
-  */
+   * Drizzle handle over the bare `env.DB` binding. Used for typed queries
+   * against generated `sqliteTable` schemas; does **not** participate in the
+   * D1 Sessions API (no bookmark pinning). For bookmark-scoped reads, use
+   * {@link drizzleSession} instead.
+   */
   get drizzle(): DrizzleD1Database<Record<string, unknown>>;
   /**
-  * Drizzle handle scoped to a D1 Sessions-API session. The bookmark, when
-  * supplied, opts into read-your-writes consistency for follow-up reads on
-  * the same session.
-  *
-  * A `D1DatabaseSession` exposes the same `prepare` / `batch` surface
-  * drizzle calls into, so a single `unknown` cast lets us treat the session
-  * as a `D1Database` for driver-construction purposes.
-  */
+   * Drizzle handle scoped to a D1 Sessions-API session. The bookmark, when
+   * supplied, opts into read-your-writes consistency for follow-up reads on
+   * the same session.
+   *
+   * A `D1DatabaseSession` exposes the same `prepare` / `batch` surface
+   * drizzle calls into, so a single `unknown` cast lets us treat the session
+   * as a `D1Database` for driver-construction purposes.
+   */
   drizzleSession(bookmark?: string): DrizzleD1Database<Record<string, unknown>>;
   /**
-  * Atomic batch over the drizzle d1 driver. Mirrors `db.batch([...])`
-  * exactly; exposed on the client so callers don't need to hold a drizzle
-  * handle just to run a typed batch.
-  */
+   * Atomic batch over the drizzle d1 driver. Mirrors `db.batch([...])`
+   * exactly; exposed on the client so callers don't need to hold a drizzle
+   * handle just to run a typed batch.
+   */
   batch<U extends BatchItem<"sqlite">, T extends Readonly<[U, ...U[]]>>(items: T): Promise<BatchResponse<T>>;
   /** Direct access to the underlying binding (advanced use only). */
   get raw(): D1DatabaseLike;
@@ -205,24 +216,24 @@ interface GlobalTableInfo {
 interface GlobalTablePage {
   columns: string[];
   /**
-  * Foreign-key columns (local column → referenced table) for tables that carry
-  * real SQL `REFERENCES` constraints — recovered from `PRAGMA foreign_key_list`.
-  * Schema `.global()` tables omit this (their refs come from `describeTables`);
-  * external tables (e.g. better-auth's `session`/`twoFactor`) expose it so the
-  * schema diagram can draw their global→global FK edges.
-  */
+   * Foreign-key columns (local column → referenced table) for tables that carry
+   * real SQL `REFERENCES` constraints — recovered from `PRAGMA foreign_key_list`.
+   * Schema `.global()` tables omit this (their refs come from `describeTables`);
+   * external tables (e.g. better-auth's `session`/`twoFactor`) expose it so the
+   * schema diagram can draw their global→global FK edges.
+   */
   refs?: Record<string, string>;
   rows: Record<string, unknown>[];
   total: number;
 }
 /**
-* One equality constraint a facet-value click adds to the global browser's view:
-* `column = value` (or `column IS NULL` when `value` is nullish). `column` is a
-* displayed column name, validated against the table's columns and mapped to its
-* physical column (`_id` → `id`) before it is quoted; `value` is the **raw stored
-* value** the facet returned (a SQLite scalar), bound as a parameter and never
-* interpolated. AND-combined with the other clauses.
-*/
+ * One equality constraint a facet-value click adds to the global browser's view:
+ * `column = value` (or `column IS NULL` when `value` is nullish). `column` is a
+ * displayed column name, validated against the table's columns and mapped to its
+ * physical column (`_id` → `id`) before it is quoted; `value` is the **raw stored
+ * value** the facet returned (a SQLite scalar), bound as a parameter and never
+ * interpolated. AND-combined with the other clauses.
+ */
 interface GlobalFilterClause {
   column: string;
   value: unknown;
@@ -234,13 +245,13 @@ interface ReadGlobalTablePageOptions {
   table: string;
 }
 /**
-* Options for {@link facetGlobalColumn} — the read-only "what values does this
-* column hold?" summary for the global (D1) browser. `column` is the displayed
-* column to group by (validated and mapped to its physical column, never
-* interpolated); `filters` mirrors {@link ReadGlobalTablePageOptions}'s eq
-* constraints so the facet reflects the **active view** (the same rows the
-* browser is previewing); `limit` caps the distinct values returned (clamped).
-*/
+ * Options for {@link facetGlobalColumn} — the read-only "what values does this
+ * column hold?" summary for the global (D1) browser. `column` is the displayed
+ * column to group by (validated and mapped to its physical column, never
+ * interpolated); `filters` mirrors {@link ReadGlobalTablePageOptions}'s eq
+ * constraints so the facet reflects the **active view** (the same rows the
+ * browser is previewing); `limit` caps the distinct values returned (clamped).
+ */
 interface FacetGlobalColumnOptions {
   column: string;
   filters?: GlobalFilterClause[];
@@ -253,43 +264,43 @@ interface GlobalFacetValue {
   value: unknown;
 }
 /**
-* Payload of a {@link facetGlobalColumn} call: the top-N distinct `values` (each
-* with a `count`) ordered by frequency, plus `truncated` — `true` when more
-* distinct values existed beyond the cap, so the UI can say so rather than imply
-* the list is exhaustive. Mirrors the shard browser's `FacetColumnResult`.
-*/
+ * Payload of a {@link facetGlobalColumn} call: the top-N distinct `values` (each
+ * with a `count`) ordered by frequency, plus `truncated` — `true` when more
+ * distinct values existed beyond the cap, so the UI can say so rather than imply
+ * the list is exhaustive. Mirrors the shard browser's `FacetColumnResult`.
+ */
 interface GlobalFacetResult {
   truncated: boolean;
   values: GlobalFacetValue[];
 }
 /**
-* List every browsable D1 table with its row count, ordered by name. Surfaces
-* both the schema's `.global()` tables (provisioned first) and external tables
-* (auth, etc.); internal/companion tables are excluded.
-*/
+ * List every browsable D1 table with its row count, ordered by name. Surfaces
+ * both the schema's `.global()` tables (provisioned first) and external tables
+ * (auth, etc.); internal/companion tables are excluded.
+ */
 declare const listGlobalTables: (exec: SqlCtxExec, schema: SchemaLike) => Promise<GlobalTableInfo[]>;
 /**
-* Read a page of rows from one D1 table. The table is validated against the live
-* browsable-table list before its name is interpolated, so this can't be coerced
-* into reading an internal table or injecting SQL. `limit` is clamped to
-* `[1, 500]`; `offset` floors at `0`. `filters` AND-narrows the page to rows
-* matching each `column = value` eq constraint (a facet-value drill-down), bound
-* through {@link buildEqPredicate} so they never inject SQL.
-*/
+ * Read a page of rows from one D1 table. The table is validated against the live
+ * browsable-table list before its name is interpolated, so this can't be coerced
+ * into reading an internal table or injecting SQL. `limit` is clamped to
+ * `[1, 500]`; `offset` floors at `0`. `filters` AND-narrows the page to rows
+ * matching each `column = value` eq constraint (a facet-value drill-down), bound
+ * through {@link buildEqPredicate} so they never inject SQL.
+ */
 declare const readGlobalTablePage: (exec: SqlCtxExec, schema: SchemaLike, options: ReadGlobalTablePageOptions) => Promise<GlobalTablePage>;
 /**
-* Summarise the distinct values of one displayed column over the **active view**
-* (the same eq `filters` the global browser is previewing) — the D1 twin of the
-* shard browser's `facetColumn`. Read-only: a `SELECT col AS value, COUNT(*) AS
-* count … GROUP BY col ORDER BY count DESC LIMIT N+1`, with the column validated
-* against the table's displayed columns (typed 404 if unknown), mapped to its
-* physical column, and quoted — never interpolated from caller input. The extra
-* over-fetched row is dropped and surfaced as `truncated`. A sensitive column on
-* an external (non-schema) table is never grouped — it collapses to a single
-* redacted `•••` bucket — mirroring the page browser's value redaction so the
-* facet can't leak credentials. The returned `value` is the raw stored scalar, so
-* a click feeds it straight back as an eq filter.
-*/
+ * Summarise the distinct values of one displayed column over the **active view**
+ * (the same eq `filters` the global browser is previewing) — the D1 twin of the
+ * shard browser's `facetColumn`. Read-only: a `SELECT col AS value, COUNT(*) AS
+ * count … GROUP BY col ORDER BY count DESC LIMIT N+1`, with the column validated
+ * against the table's displayed columns (typed 404 if unknown), mapped to its
+ * physical column, and quoted — never interpolated from caller input. The extra
+ * over-fetched row is dropped and surfaced as `truncated`. A sensitive column on
+ * an external (non-schema) table is never grouped — it collapses to a single
+ * redacted `•••` bucket — mirroring the page browser's value redaction so the
+ * facet can't leak credentials. The returned `value` is the raw stored scalar, so
+ * a click feeds it straight back as an eq filter.
+ */
 declare const facetGlobalColumn: (exec: SqlCtxExec, schema: SchemaLike, options: FacetGlobalColumnOptions) => Promise<GlobalFacetResult>;
 interface Migration {
   /** Human-readable name, e.g. `001_init` (used in logs). */
@@ -310,20 +321,20 @@ interface MigrationRunnerResult {
   }[];
 }
 /**
-* Sequentially applies pending migrations against a D1 database via the
-* drizzle-orm/d1 driver. Each migration is hashed (SHA-256 over its SQL
-* text); the hash is stored in `__drizzle_migrations`, so re-applying the
-* same SQL under a different `version` is rejected and identical migrations
-* are skipped idempotently.
-*/
+ * Sequentially applies pending migrations against a D1 database via the
+ * drizzle-orm/d1 driver. Each migration is hashed (SHA-256 over its SQL
+ * text); the hash is stored in `__drizzle_migrations`, so re-applying the
+ * same SQL under a different `version` is rejected and identical migrations
+ * are skipped idempotently.
+ */
 declare class MigrationRunner {
   private readonly client;
   private readonly migrations;
   /**
-  * Accepts either a {@link D1Client} (preferred — gets typed batches +
-  * drizzle handle for free) or a raw `D1DatabaseLike` binding (wrapped on
-  * the caller's behalf so existing `@lunora/cli` callers keep working).
-  */
+   * Accepts either a {@link D1Client} (preferred — gets typed batches +
+   * drizzle handle for free) or a raw `D1DatabaseLike` binding (wrapped on
+   * the caller's behalf so existing `@lunora/cli` callers keep working).
+   */
   constructor(database: D1Client | D1DatabaseLike, migrations: Migration[]);
   run(): Promise<MigrationRunnerResult>;
   private applyOne;
@@ -331,9 +342,9 @@ declare class MigrationRunner {
   private assertUniqueSql;
 }
 /**
-* The canonical SQLite dialect: column affinities, the shared SQLite value
-* codec, `RETURNING` support (both D1 and `node:sqlite`), and `sqlite_master`
-* table probing. The rest of the per-statement shaping is drizzle's.
-*/
+ * The canonical SQLite dialect: column affinities, the shared SQLite value
+ * codec, `RETURNING` support (both D1 and `node:sqlite`), and `sqlite_master`
+ * table probing. The rest of the per-statement shaping is drizzle's.
+ */
 declare const sqliteDialect: SqlDialect;
-export { D1Client, type D1ContextDatabaseOptions as D1CtxDbOptions, type D1DatabaseLike, type D1PreparedStatementLike, D1Session, type D1SessionLike, type ExportGlobalArgs, type FacetGlobalColumnOptions, type ExportRow as GlobalExportRow, type GlobalFacetResult, type GlobalFacetValue, type GlobalFilterClause, type ImportError as GlobalImportError, type ImportResult as GlobalImportResult, type GlobalTableInfo, type GlobalTablePage, type ImportGlobalArgs, type Migration, MigrationRunner, type MigrationRunnerResult, type ReadGlobalTablePageOptions, createD1ContextDatabase as createD1CtxDb, exportGlobalRows, facetGlobalColumn, importGlobalRows, listGlobalTables, readD1CdcChanges, readGlobalTablePage, runD1AggregateMigrations, runD1CdcMigration, runD1GlobalTableMigrations, runD1RankMigrations, runD1SearchMigrations, selectGlobalTables, sqliteDialect, trimD1CdcChanges };
+export { D1Client, type D1ContextDatabaseOptions as D1CtxDbOptions, type D1DatabaseLike, type D1PreparedStatementLike, D1Session, type D1SessionLike, type ExportGlobalArgs, type FacetGlobalColumnOptions, type ExportRow as GlobalExportRow, type GlobalFacetResult, type GlobalFacetValue, type GlobalFilterClause, type ImportError as GlobalImportError, type ImportResult as GlobalImportResult, type GlobalTableInfo, type GlobalTablePage, type ImportGlobalArgs, type Migration, MigrationRunner, type MigrationRunnerResult, type ReadGlobalTablePageOptions, backfillD1SearchIndexes, createD1ContextDatabase as createD1CtxDb, exportGlobalRows, facetGlobalColumn, importGlobalRows, listGlobalTables, readD1CdcChanges, readGlobalTablePage, runD1AggregateMigrations, runD1CdcMigration, runD1GlobalTableMigrations, runD1RankMigrations, runD1SearchMigrations, selectGlobalTables, sqliteDialect, trimD1CdcChanges };

package/dist/index.mjs

@@ -1,7 +1 @@
-export { exportGlobalRows, importGlobalRows, selectGlobalTables } from './packem_shared/exportGlobalRows-BGCPm_nA.mjs';
-export { D1Client, D1Session } from './packem_shared/D1Client-DA3flo1o.mjs';
-export { createD1CtxDb, readD1CdcChanges, runD1AggregateMigrations, runD1CdcMigration, runD1GlobalTableMigrations, runD1RankMigrations, runD1SearchMigrations, trimD1CdcChanges } from './packem_shared/createD1CtxDb-BMR8J0dT.mjs';
-export { facetGlobalColumn, listGlobalTables, readGlobalTablePage } from './packem_shared/facetGlobalColumn-C6u_WMIY.mjs';
-export { MigrationRunner } from './packem_shared/MigrationRunner-BkEwQ-Ya.mjs';
-export { default as sqliteDialect } from './packem_shared/sqliteDialect-DqYnHPuu.mjs';
-export { createSqlCtxDb } from '@lunora/sql-store';
+import{exportGlobalRows as a,importGlobalRows as o,selectGlobalTables as l}from"./packem_shared/exportGlobalRows-CmcmGZxv.mjs";import{D1Client as i,D1Session as n}from"./packem_shared/D1Client-B9m0fFLr.mjs";import{backfillD1SearchIndexes as b,createD1CtxDb as D,readD1CdcChanges as g,runD1AggregateMigrations as c,runD1CdcMigration as x,runD1GlobalTableMigrations as f,runD1RankMigrations as m,runD1SearchMigrations as p,trimD1CdcChanges as C}from"./packem_shared/backfillD1SearchIndexes-ERQf6szv.mjs";import{facetGlobalColumn as d,listGlobalTables as G,readGlobalTablePage as M}from"./packem_shared/facetGlobalColumn-R-BETSuA.mjs";import{MigrationRunner as R}from"./packem_shared/MigrationRunner-DvnPBDVT.mjs";import{default as T}from"./packem_shared/sqliteDialect-B43yA0ek.mjs";import{createSqlCtxDb as q}from"@lunora/sql-store";export{i as D1Client,n as D1Session,R as MigrationRunner,b as backfillD1SearchIndexes,D as createD1CtxDb,q as createSqlCtxDb,a as exportGlobalRows,d as facetGlobalColumn,o as importGlobalRows,G as listGlobalTables,g as readD1CdcChanges,M as readGlobalTablePage,c as runD1AggregateMigrations,x as runD1CdcMigration,f as runD1GlobalTableMigrations,m as runD1RankMigrations,p as runD1SearchMigrations,l as selectGlobalTables,T as sqliteDialect,C as trimD1CdcChanges};

package/dist/packem_shared/D1Client-B9m0fFLr.mjs

@@ -0,0 +1 @@
+import{drizzle as n}from"drizzle-orm/d1";const d=(t,e)=>{if(t.size<e)return;const s=t.keys().next().value;s!==void 0&&t.delete(s)},l=256,o=(t,e,s)=>{const r=t.get(s);if(r)return t.delete(s),t.set(s,r),r;const i=e(s);return d(t,l),t.set(s,i),i},a="first-unconstrained";class h{session;stmtCache=new Map;constructor(e){this.session=e}prepare(e){return o(this.stmtCache,s=>this.session.prepare(s),e)}async run(e,...s){return this.prepare(e).bind(...s).run()}async all(e,...s){return this.prepare(e).bind(...s).all()}async first(e,...s){return this.prepare(e).bind(...s).first()}getBookmark(){return this.session.getBookmark()??void 0}}class u{db;stmtCache=new Map;drizzleHandle;constructor(e){this.db=e}withSession(e){const s=this.db.withSession(e??a);return new h(s)}prepare(e){return o(this.stmtCache,s=>this.db.prepare(s),e)}get drizzle(){return this.drizzleHandle?this.drizzleHandle:(this.drizzleHandle=n(this.db,{logger:!1}),this.drizzleHandle)}drizzleSession(e){const s=this.db.withSession(e??a);return n(s,{logger:!1})}async batch(e){return this.drizzle.batch(e)}get raw(){return this.db}}export{u as D1Client,h as D1Session};

package/dist/packem_shared/MigrationRunner-DvnPBDVT.mjs

@@ -0,0 +1,2 @@
+import{LunoraError as u}from"@lunora/errors";import{sql as h}from"drizzle-orm";import{D1Client as m}from"./D1Client-B9m0fFLr.mjs";const f="__drizzle_migrations",w=`CREATE TABLE IF NOT EXISTS ${f} (id INTEGER PRIMARY KEY AUTOINCREMENT, hash TEXT NOT NULL UNIQUE, created_at NUMERIC)`,d=/\s/u,g=/^[0-9a-f]{64}$/u,p=new RegExp(String.raw`UNIQUE constraint failed:\s*${f}\.hash`,"iu"),E=c=>{const n=c.sql;let i=!1,e=!1,r=!1,o=!1,a;for(let t=0;t<n.length;t+=1){const s=n[t],l=n[t+1];if(r){s===`
+`&&(r=!1);continue}if(o){s==="*"&&l==="/"&&(o=!1,t+=1);continue}if(i){s==="'"&&(l==="'"?t+=1:i=!1);continue}if(e){s==='"'&&(l==='"'?t+=1:e=!1);continue}if(s==="-"&&l==="-"){r=!0,t+=1;continue}if(s==="/"&&l==="*"){o=!0,t+=1;continue}if(a!==void 0){if(s!==void 0&&!d.test(s))throw new u("INTERNAL",`Migration "${c.name}" (v${String(c.version)}) contains more than one SQL statement. Split it into separate migrations — batch() runs them atomically.`);continue}if(s==="'"){i=!0;continue}if(s==='"'){e=!0;continue}s===";"&&(a=t)}return a},S=async c=>{const n=new TextEncoder().encode(c),i=await crypto.subtle.digest("SHA-256",n);return[...new Uint8Array(i)].map(e=>e.toString(16).padStart(2,"0")).join("")};class I{client;migrations;constructor(n,i){this.client=n instanceof m?n:new m(n),this.migrations=[...i].toSorted((e,r)=>e.version-r.version),this.assertUniqueVersions(),this.assertUniqueSql()}async run(){await this.client.drizzle.run(h.raw(w));const n=await this.client.drizzle.all(h.raw(`SELECT hash FROM ${f}`)),i=new Set(n.map(a=>a.hash)),e=[],r=[],o=await Promise.all(this.migrations.map(async a=>S(a.sql)));for(const[a,t]of this.migrations.entries()){const s=o[a];if(i.has(s)){r.push({name:t.name,version:t.version});continue}await this.applyOne(t,s)?e.push({name:t.name,version:t.version}):r.push({name:t.name,version:t.version})}return{applied:e,skipped:r}}async applyOne(n,i){const e=E(n),r=(e===void 0?n.sql:n.sql.slice(0,e)).trim();if(!g.test(i))throw new u("INTERNAL",`migration "${n.name}" produced a non-hex hash; refusing to inline into SQL`);const o=`INSERT INTO ${f} (hash, created_at) VALUES ('${i}', ${String(Date.now())})`,a=[this.client.drizzle.run(h.raw(r)),this.client.drizzle.run(h.raw(o))];try{await this.client.batch(a)}catch(t){if(p.test(t instanceof Error?t.message:String(t)))return!1;throw t}return!0}assertUniqueVersions(){const n=new Set;for(const i of this.migrations){if(n.has(i.version))throw new u("INTERNAL",`Duplicate migration version ${String(i.version)}`);n.add(i.version)}}assertUniqueSql(){const n=new Map;for(const i of this.migrations){const e=n.get(i.sql);if(e!==void 0)throw new u("INTERNAL",`Migrations ${String(e)} and ${String(i.version)} have identical SQL — bump the content, not just the version.`);n.set(i.sql,i.version)}}}export{I as MigrationRunner};

package/dist/packem_shared/backfillD1SearchIndexes-ERQf6szv.mjs

@@ -0,0 +1 @@
+import{backfillSqlSearchIndexes as n,createSqlCtxDb as i,readSqlCdcChanges as t,runSqlAggregateMigrations as s,runSqlCdcMigration as l,runSqlGlobalTableMigrations as o,runSqlRankMigrations as g,runSqlSearchMigrations as c,trimSqlCdcChanges as d}from"@lunora/sql-store";import{createSqlCtxDb as G,decodeGlobalRow as R}from"@lunora/sql-store";import e from"./sqliteDialect-B43yA0ek.mjs";const D=a=>i({...a,dialect:e}),b=(a,r)=>o(a,r,e),q=(a,r)=>s(a,r,e),u=(a,r)=>g(a,r,e),M=(a,r)=>c(a,r,e),h=(a,r)=>n(a,r,e),m=a=>l(a,e),x=(a,r={})=>t(a,r,e),f=(a,r)=>d(a,r,e);export{h as backfillD1SearchIndexes,D as createD1CtxDb,G as createSqlCtxDb,R as decodeGlobalRow,x as readD1CdcChanges,q as runD1AggregateMigrations,m as runD1CdcMigration,b as runD1GlobalTableMigrations,u as runD1RankMigrations,M as runD1SearchMigrations,f as trimD1CdcChanges};

package/dist/packem_shared/exportGlobalRows-CmcmGZxv.mjs

@@ -0,0 +1 @@
+import{toErrorBody as u}from"@lunora/errors";import{runD1GlobalTableMigrations as m}from"./backfillD1SearchIndexes-ERQf6szv.mjs";import{quoteIdentifier as f}from"./quoteIdentifier-CObIFRhb.mjs";import{decodeGlobalRow as E}from"@lunora/sql-store";const R=200,g=(o,t)=>{const r=e=>o.tables[e]?.shardMode?.kind==="global";return t&&t.length>0?t.filter(e=>r(e)):Object.keys(o.tables).filter(e=>r(e))},k=(o,t,r)=>{const e=o.tables[t];return e?E(e,r):{_creationTime:r._creationTime,_id:r.id}},O=async function*(o,t,r){const e=g(t,r.tables),a=r.batchSize??R;await m(o,t);for(const i of e){const n=f(i);let c,s=!0;for(;s;){const l=c===void 0?await o.all(`SELECT * FROM ${n} ORDER BY "id" LIMIT ?`,[a]):await o.all(`SELECT * FROM ${n} WHERE "id" > ? ORDER BY "id" LIMIT ?`,[c,a]);for(const b of l)yield{doc:k(t,i,b),table:i};const d=l.at(-1);d!==void 0&&(c=String(d.id)),s=l.length===a}}},w=(o,t,r)=>{const e=o.tables[t];if(!e)return`unknown table: ${t}`;for(const[a,i]of Object.entries(e.shape)){const n=r[a],c=i.kind==="optional";if(n===void 0&&c)continue;const s=i.parse;if(typeof s=="function")try{s(n)}catch(l){const d=l instanceof Error?l.message:String(l);return`field "${a}": ${d}`}}},y=async(o,t,r,e)=>{try{return t?(await t.all(`SELECT 1 AS hit FROM ${f(r)} WHERE "id" = ? LIMIT 1`,[e])).length>0:await o.get(e)!==null}catch{return!1}},p=async(o,t,r,e,a)=>{const{doc:i,table:n}=e;if(t.tables[n]?.shardMode?.kind!=="global")return{kind:"skip"};if(!i||typeof i!="object"||Array.isArray(i))return{error:{code:"BAD_ROW",line:a,message:"row is missing or malformed `doc`",table:n},kind:"error"};const c=w(t,n,i);if(c!==void 0)return{error:{code:"VALIDATION_ERROR",line:a,message:c,table:n},kind:"error"};const s=typeof i._id=="string"?i._id:void 0;if(s!==void 0&&await y(o,r.exec,n,s))return{kind:"conflict"};try{return await o.insert(n,i,{allowExplicitId:!0}),{inserted:n,kind:"inserted"}}catch(l){const{body:d}=u(l,{fallbackCode:"INSERT_FAILED"});return{error:{code:d.code,line:a,message:d.message,table:n},kind:"error"}}},M=async(o,t,r)=>{const e=[],a={};let i=0,n=(r.startLine??1)-1;for(const c of r.rows){n+=1;const s=await p(o,t,r,c,n);switch(s.kind){case"conflict":{i+=1;break}case"error":{e.push(s.error);break}case"inserted":{a[s.inserted]=(a[s.inserted]??0)+1;break}}}return{conflicts:i,errors:e,inserted:a}};export{O as exportGlobalRows,M as importGlobalRows,g as selectGlobalTables};

package/dist/packem_shared/facetGlobalColumn-R-BETSuA.mjs

@@ -0,0 +1 @@
+import{LunoraError as _}from"@lunora/errors";import{runD1GlobalTableMigrations as T}from"./backfillD1SearchIndexes-ERQf6szv.mjs";import{quoteIdentifier as i}from"./quoteIdentifier-CObIFRhb.mjs";import{decodeGlobalRow as S}from"@lunora/sql-store";const E=(t,a)=>T(t,a),L=50,g=500,y=30,C=200,O=(t,a,o)=>Math.min(Math.max(t,a),o),A=/^sqlite_|^_cf_|^d1_|^__cdc|__agg_|__rank_|__fts_/u,U=t=>A.test(t),N=/password|secret|token|hash|salt|credential/iu,p=async t=>(await t.all("SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name",[])).map(a=>String(a.name)).filter(a=>!U(a)),$=async(t,a,o="",n=[])=>{const s=await t.all(`SELECT COUNT(*) AS c FROM ${a}${o}`,n);return Number(s[0]?.c??0)},v=(t,a,o)=>t.tables[a]!==void 0&&o==="_id"?"id":o,M=(t,a,o,n)=>{if(n===void 0||n.length===0)return;const s=[],l=[];for(const e of n){if(!o.includes(e.column))throw new _("UNKNOWN_COLUMN",`unknown column: ${e.column}`,{status:404});if(t.tables[a]===void 0&&N.test(e.column))throw new _("FORBIDDEN",`cannot filter on a redacted column: ${e.column}`,{status:403});const r=i(v(t,a,e.column));e.value===null||e.value===void 0?s.push(`${r} IS NULL`):(s.push(`${r} = ?`),l.push(e.value))}return{params:l,where:s.join(" AND ")}},G=(t,a,o)=>{const n=t.tables[a];if(n)return S(n,o);const s={};for(const[l,e]of Object.entries(o))s[l]=e!=null&&N.test(l)?"•••":e;return s},R=async(t,a,o)=>{const n=a.tables[o];return n?["_id","_creationTime",...Object.keys(n.shape)]:(await t.all(`PRAGMA table_info(${i(o)})`,[])).map(s=>String(s.name))},k=async(t,a,o)=>{if(a.tables[o])return;const n=await t.all(`PRAGMA foreign_key_list(${i(o)})`,[]);if(n.length===0)return;const s={};for(const l of n){const e=String(l.from),r=String(l.table);s[e]??=r}return s},B=async(t,a)=>{await E(t,a);const o=await p(t);return Promise.all(o.map(async n=>({name:n,rowCount:await $(t,i(n))})))},P=async(t,a,o)=>{const{table:n}=o;if(await E(t,a),!(await p(t)).includes(n))throw new _("UNKNOWN_TABLE",`unknown table: ${n}`,{status:404});const s=O(Math.trunc(o.limit??L),1,g),l=Math.max(0,Math.trunc(o.offset??0)),e=i(n),r=await R(t,a,n),u=M(a,n,r,o.filters),w=u===void 0?"":` WHERE ${u.where}`,c=u?.params??[],f=await $(t,e,w,c),m=(await t.all(`SELECT * FROM ${e}${w} LIMIT ? OFFSET ?`,[...c,s,l])).map(h=>G(a,n,h)),d=await k(t,a,n);return d===void 0?{columns:r,rows:m,total:f}:{columns:r,refs:d,rows:m,total:f}},K=async(t,a,o)=>{const{column:n,table:s}=o;if(await E(t,a),!(await p(t)).includes(s))throw new _("UNKNOWN_TABLE",`unknown table: ${s}`,{status:404});const l=await R(t,a,s);if(!l.includes(n))throw new _("UNKNOWN_COLUMN",`unknown column: ${n}`,{status:404});const e=i(s),r=M(a,s,l,o.filters),u=r===void 0?"":` WHERE ${r.where}`,w=r?.params??[];if(a.tables[s]===void 0&&N.test(n)){const b=await $(t,e,u,w);return{truncated:!1,values:b===0?[]:[{count:b,value:"•••"}]}}const c=O(Math.trunc(o.limit??y),1,C),f=i(v(a,s,n)),m=await t.all(`SELECT ${f} AS value, COUNT(*) AS count FROM ${e}${u} GROUP BY ${f} ORDER BY count DESC LIMIT ?`,[...w,c+1]),d=m.length>c,h=d?m.slice(0,c):m;return{truncated:d,values:h.map(b=>({count:Number(b.count),value:b.value}))}};export{K as facetGlobalColumn,B as listGlobalTables,P as readGlobalTablePage};

package/dist/packem_shared/quoteIdentifier-CObIFRhb.mjs

@@ -0,0 +1 @@
+const t=e=>`"${e.replaceAll('"','""')}"`;export{t as quoteIdentifier};

package/dist/packem_shared/sqliteDialect-B43yA0ek.mjs

@@ -0,0 +1 @@
+import{sqliteEncode as i,sqliteDecode as n}from"@lunora/sql-store";import{sql as o}from"drizzle-orm";import{sqlAffinityForKind as r}from"../dialect.mjs";const s=/unique constraint failed/iu,T={companionTypes:{autoincrementPrimaryKey:"INTEGER PRIMARY KEY AUTOINCREMENT",integer:"INTEGER",key:"TEXT",real:"REAL",text:"TEXT"},columnType:e=>r(e),decode:(e,t)=>n(e,t),encode:e=>i(e),frameworkColumns:()=>[{name:"id",type:"TEXT PRIMARY KEY"},{name:"_creationTime",type:"REAL NOT NULL"}],isUniqueViolation:e=>e instanceof Error&&s.test(e.message),name:"sqlite",supportsFts5:!0,supportsReturning:!0,tableExists:e=>o`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${e}`};export{T as default};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/d1",
-  "version": "1.0.0-alpha.5",
+  "version": "1.0.0-alpha.50",
   "description": "D1 adapter for Lunora .global() tables, wrapping the Sessions API for read-your-writes",
   "keywords": [
     "cloudflare",
@@ -25,7 +25,7 @@
     "directory": "packages/d1"
   },
   "files": [
-    "dist",
+    "./dist",
     "README.md",
     "LICENSE.md",
     "__assets__"
@@ -50,8 +50,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/do": "1.0.0-alpha.5",
-    "@lunora/sql-store": "1.0.0-alpha.5",
+    "@lunora/do": "1.0.0-alpha.54",
+    "@lunora/errors": "1.0.0-alpha.9",
+    "@lunora/sql-store": "1.0.0-alpha.51",
     "drizzle-orm": "^0.45.2"
   },
   "engines": {

package/dist/packem_shared/D1Client-DA3flo1o.mjs

@@ -1,143 +0,0 @@
-import { drizzle } from 'drizzle-orm/d1';
-
-const STMT_CACHE_CAPACITY = 256;
-const D1_FIRST_UNCONSTRAINED = "first-unconstrained";
-class D1Session {
-  session;
-  /** See {@link D1Client.stmtCache}. Scoped per session. */
-  stmtCache = /* @__PURE__ */ new Map();
-  constructor(session) {
-    this.session = session;
-  }
-  prepare(sql) {
-    const cached = this.stmtCache.get(sql);
-    if (cached) {
-      this.stmtCache.delete(sql);
-      this.stmtCache.set(sql, cached);
-      return cached;
-    }
-    const stmt = this.session.prepare(sql);
-    if (this.stmtCache.size >= STMT_CACHE_CAPACITY) {
-      const oldest = this.stmtCache.keys().next().value;
-      if (oldest !== void 0) {
-        this.stmtCache.delete(oldest);
-      }
-    }
-    this.stmtCache.set(sql, stmt);
-    return stmt;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- T types the result rows for the caller and is forwarded to the prepared statement.
-  async run(sql, ...binds) {
-    return this.prepare(sql).bind(...binds).run();
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- T types the result rows for the caller and is forwarded to the prepared statement.
-  async all(sql, ...binds) {
-    return this.prepare(sql).bind(...binds).all();
-  }
-  async first(sql, ...binds) {
-    return this.prepare(sql).bind(...binds).first();
-  }
-  /**
-   * Returns the most recent bookmark known to the session, or `undefined`
-   * when D1 has not issued one yet.
-   */
-  getBookmark() {
-    return this.session.getBookmark() ?? void 0;
-  }
-}
-class D1Client {
-  db;
-  /**
-   * SQL string -> prepared statement. Prepared statements are reusable in
-   * D1; preparing the same SQL twice forces the worker to round-trip the
-   * statement plan. Caching is per-instance so unit-test isolation holds.
-   * Bounded to {@link STMT_CACHE_CAPACITY} via LRU eviction.
-   */
-  stmtCache = /* @__PURE__ */ new Map();
-  /**
-   * Lazily-built drizzle handle over the bare binding. Memoised so a single
-   * `D1Client` reuses the same dialect/session machinery across calls.
-   */
-  drizzleHandle;
-  constructor(database) {
-    this.db = database;
-  }
-  /**
-   * Open a Sessions-API scoped session. Pass the bookmark forwarded by
-   * the client to opt into read-your-writes consistency.
-   *
-   * With no bookmark this is the first request of a session — there is no
-   * prior write to read, so we open with the explicit `"first-unconstrained"`
-   * constraint (Cloudflare's lowest-latency default: the first read may serve
-   * from any replica). Read-your-writes for sequenced requests still flows
-   * through the forwarded bookmark; a caller needing a strongly-consistent
-   * very-first read should pass `"first-primary"` as the bookmark instead.
-   */
-  withSession(bookmark) {
-    const session = this.db.withSession(bookmark ?? D1_FIRST_UNCONSTRAINED);
-    return new D1Session(session);
-  }
-  /**
-   * Prepare a statement, reusing a cached one when the SQL text matches.
-   * `bind()` on a prepared statement returns a new bound statement and
-   * leaves the underlying prepared plan reusable, so cache hits are safe
-   * even when the previous caller already called `.bind(...).run()`.
-   */
-  prepare(sql) {
-    const cached = this.stmtCache.get(sql);
-    if (cached) {
-      this.stmtCache.delete(sql);
-      this.stmtCache.set(sql, cached);
-      return cached;
-    }
-    const stmt = this.db.prepare(sql);
-    if (this.stmtCache.size >= STMT_CACHE_CAPACITY) {
-      const oldest = this.stmtCache.keys().next().value;
-      if (oldest !== void 0) {
-        this.stmtCache.delete(oldest);
-      }
-    }
-    this.stmtCache.set(sql, stmt);
-    return stmt;
-  }
-  /**
-   * Drizzle handle over the bare `env.DB` binding. Used for typed queries
-   * against generated `sqliteTable` schemas; does **not** participate in the
-   * D1 Sessions API (no bookmark pinning). For bookmark-scoped reads, use
-   * {@link drizzleSession} instead.
-   */
-  get drizzle() {
-    if (this.drizzleHandle) {
-      return this.drizzleHandle;
-    }
-    this.drizzleHandle = drizzle(this.db, { logger: false });
-    return this.drizzleHandle;
-  }
-  /**
-   * Drizzle handle scoped to a D1 Sessions-API session. The bookmark, when
-   * supplied, opts into read-your-writes consistency for follow-up reads on
-   * the same session.
-   *
-   * A `D1DatabaseSession` exposes the same `prepare` / `batch` surface
-   * drizzle calls into, so a single `unknown` cast lets us treat the session
-   * as a `D1Database` for driver-construction purposes.
-   */
-  drizzleSession(bookmark) {
-    const session = this.db.withSession(bookmark ?? D1_FIRST_UNCONSTRAINED);
-    return drizzle(session, { logger: false });
-  }
-  /**
-   * Atomic batch over the drizzle d1 driver. Mirrors `db.batch([...])`
-   * exactly; exposed on the client so callers don't need to hold a drizzle
-   * handle just to run a typed batch.
-   */
-  async batch(items) {
-    return this.drizzle.batch(items);
-  }
-  /** Direct access to the underlying binding (advanced use only). */
-  get raw() {
-    return this.db;
-  }
-}
-
-export { D1Client, D1Session };