@earth-app/collegedb 1.1.2 → 1.1.4

package/README.md

@@ -23,6 +23,8 @@ A TypeScript library for **true horizontal scaling** of SQLite-style databases p
 - [Multi-Key Shard Mappings](#multi-key-shard-mappings)
 - [Drop-in Replacement for Existing Databases](#drop-in-replacement-for-existing-databases)
 - [Troubleshooting](#troubleshooting)
+- [Cross-Shard Pagination Behavior](#cross-shard-pagination-behavior)
+- [Database Query Best Practices](#database-query-best-practices)
 - [API Reference](#api-reference)
 - [Architecture](#architecture)
 - [Cloudflare Setup](#cloudflare-setup)
@@ -69,6 +71,7 @@ This allows you to:
 - Automatic query routing (primary key to shard mapping)
 - Provider adapters for Redis/Valkey/NuxtHub KV plus PostgreSQL/MySQL/SQLite SQL
 - Drizzle interop through existing SQL providers (`createPostgreSQLProvider`, `createMySQLProvider`, `createSQLiteProvider`)
+- Auto-allocated generated-id inserts via `insert()` and direct-shard inserts via `insertShard()` for AUTOINCREMENT / RETURNING workflows
 - Hyperdrive helpers for PostgreSQL and MySQL
 - Multiple allocation strategies: round-robin, random, hash, location-aware, and mixed read/write strategies
 - Durable Object shard coordination and shard statistics
@@ -191,18 +194,19 @@ CollegeDB includes a benchmark runner that executes each SQL+KV combination acro
 
 ### Scenario Catalog
 
-| Scenario Key      | Scenario                         | What Happens                                                                                        | Workload Per Run                                                       |
-| ----------------- | -------------------------------- | --------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- |
-| basic_crud        | Basic CRUD round-trip            | Insert, read, update, and delete a user via routed queries.                                         | 20 iterations; 4 routed SQL ops per iteration                          |
-| advanced_usage    | Advanced lookup workflow         | Writes user+post, adds lookup aliases, then validates join and alias-based lookup.                  | 15 iterations; ~5 routed SQL ops + KV lookup-key updates per iteration |
-| migration_mapping | Migration-style mapping creation | Inserts legacy records on a fixed shard, then builds shard mappings in batch and validates routing. | 10 iterations; 20 legacy records mapped per iteration                  |
-| bulk_crud         | Bulk CRUD pressure               | Performs bulk inserts, half updates, and full delete sweep, then validates shard-wide totals.       | 7 iterations; 160 inserts + 80 updates + 160 deletes per iteration     |
-| indexing          | Indexed query scan               | Creates an index on posts(user_id) and repeatedly queries the indexed path.                         | 15 iterations after warmup dataset build                               |
-| metadata_fetch    | Metadata inspection              | Reads table metadata/introspection rows from one shard.                                             | 14 iterations; 1 metadata query per iteration                          |
-| pragma_or_info    | PRAGMA / server info             | Runs provider-specific PRAGMA/info query to sample low-level metadata latency.                      | 14 iterations; 1 pragma/info query per iteration                       |
-| counting          | Cross-shard counting             | Counts users across all shards to measure fanout aggregation overhead.                              | 14 iterations; all-shard count aggregation per iteration               |
-| shard_fanout      | Shard fanout query               | Runs query fanout to all shards and aggregates shard-level responses.                               | 14 iterations; 1 all-shards query per iteration                        |
-| reassignment      | Shard reassignment flow          | Creates a record, reassigns it to another shard, and verifies routed reads still succeed.           | 10 iterations; insert + reassignment + verification per iteration      |
+| Scenario Key      | Scenario                         | What Happens                                                                                                                    | Workload Per Run                                                       |
+| ----------------- | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- |
+| basic_crud        | Basic CRUD round-trip            | Insert, read, update, and delete a user via routed queries.                                                                     | 20 iterations; 4 routed SQL ops per iteration                          |
+| advanced_usage    | Advanced lookup workflow         | Writes user+post, adds lookup aliases, then validates join and alias-based lookup.                                              | 15 iterations; ~5 routed SQL ops + KV lookup-key updates per iteration |
+| migration_mapping | Migration-style mapping creation | Inserts legacy records on a fixed shard, then builds shard mappings in batch and validates routing.                             | 10 iterations; 20 legacy records mapped per iteration                  |
+| bulk_crud         | Bulk CRUD pressure               | Performs bulk inserts, half updates, and full delete sweep, then validates shard-wide totals.                                   | 7 iterations; 160 inserts + 80 updates + 160 deletes per iteration     |
+| auto_increment    | Auto-generated primary keys      | Inserts rows with generated ids on an automatically selected shard, captures the generated key, then validates routed readback. | 6 iterations; insert + generated-id readback per iteration             |
+| indexing          | Indexed query scan               | Creates an index on posts(user_id) and repeatedly queries the indexed path.                                                     | 15 iterations after warmup dataset build                               |
+| metadata_fetch    | Metadata inspection              | Reads table metadata/introspection rows from one shard.                                                                         | 14 iterations; 1 metadata query per iteration                          |
+| pragma_or_info    | PRAGMA / server info             | Runs provider-specific PRAGMA/info query to sample low-level metadata latency.                                                  | 14 iterations; 1 pragma/info query per iteration                       |
+| counting          | Cross-shard counting             | Counts users across all shards to measure fanout aggregation overhead.                                                          | 14 iterations; all-shard count aggregation per iteration               |
+| shard_fanout      | Shard fanout query               | Runs query fanout to all shards and aggregates shard-level responses.                                                           | 14 iterations; 1 all-shards query per iteration                        |
+| reassignment      | Shard reassignment flow          | Creates a record, reassigns it to another shard, and verifies routed reads still succeed.                                       | 10 iterations; insert + reassignment + verification per iteration      |
 
 ### Report Matrices
 
@@ -437,6 +441,7 @@ Benchmark coverage includes:
 - advanced lookup/routing workflows
 - migration-style mapping creation
 - bulk CRUD
+- auto-generated primary key inserts and readback
 - indexing queries
 - metadata fetch
 - pragma/info queries (provider-specific)
@@ -570,6 +575,67 @@ This approach provides:
 - **Optimal read performance**: Queries use `hash` strategy for consistent, high-performance routing
 - **Flexibility**: Each operation type can use the most appropriate routing strategy
 
+### Auto-Generated Primary Keys
+
+When your table assigns the primary key during insert, use `insert()` for the automatic shard-allocation path or `insertShard()` when you already know the target shard. Both helpers capture the generated id from provider metadata or `RETURNING` rows, then store the generated-id mapping so the normal routed `first()` / `all()` helpers can read the row back.
+
+```typescript
+import { first, insert, insertShard } from '@earth-app/collegedb';
+
+// SQLite / D1
+await createSchema(
+	env['db-east'],
+	`
+	CREATE TABLE IF NOT EXISTS auto_users (
+		id INTEGER PRIMARY KEY AUTOINCREMENT,
+		name TEXT NOT NULL,
+		email TEXT UNIQUE,
+		created_at INTEGER
+	)
+`
+);
+
+const created = await insert('INSERT INTO auto_users (name, email, created_at) VALUES (?, ?, ?)', ['Ada', 'ada@example.com', Date.now()]);
+
+const row = await first(String(created.generatedId), 'SELECT * FROM auto_users WHERE id = ?', [created.generatedId]);
+```
+
+```typescript
+// Direct shard insert when you want to pin the write to a specific shard
+const directCreated = await insertShard('db-east', 'INSERT INTO auto_users (name, email, created_at) VALUES (?, ?, ?)', [
+	'Ada',
+	'ada@example.com',
+	Date.now()
+]);
+
+console.log(directCreated.generatedId);
+```
+
+```typescript
+// PostgreSQL / MySQL 8.0.19+ RETURNING path
+await createSchema(
+	env['db-east'],
+	`
+	CREATE TABLE IF NOT EXISTS auto_users (
+		id BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+		name VARCHAR(255) NOT NULL,
+		email VARCHAR(255) UNIQUE,
+		created_at BIGINT
+	)
+`
+);
+
+const created = await insert('INSERT INTO auto_users (name, email, created_at) VALUES (?, ?, ?) RETURNING id', [
+	'Ada',
+	'ada@example.com',
+	Date.now()
+]);
+
+const row = await first(String(created.generatedId), 'SELECT * FROM auto_users WHERE id = ?', [created.generatedId]);
+```
+
+If your SQL dialect uses `RETURNING`, include it in the insert statement. The helper will use the returned row instead of provider metadata when present.
+
 ## Multi-Key Shard Mappings
 
 CollegeDB supports **multiple lookup keys** for the same record, allowing you to query by username, email, ID, or any unique identifier. Keys are automatically hashed with SHA-256 for security and privacy.
@@ -616,6 +682,22 @@ await mapper.addLookupKeys('user-456', ['email:jane@example.com', 'username:jane
 const user = await first('email:jane@example.com', 'SELECT * FROM users WHERE email = ?', ['jane@example.com']);
 ```
 
+### Lookup-Key Read Helpers With Fanout Fallback
+
+When you query by a secondary key and want safe behavior even when a lookup mapping is missing or stale, use the router-level helpers:
+
+```typescript
+import { allByLookupKey, firstByLookupKey } from '@earth-app/collegedb';
+
+// Uses lookup-key mapping when present, then falls back to all-shard fanout if needed
+const user = await firstByLookupKey('email:john@example.com', 'SELECT * FROM users WHERE email = ? LIMIT 1', ['john@example.com']);
+
+// Same resolution flow, but returns merged row sets
+const matches = await allByLookupKey('username:john_doe', 'SELECT id, username FROM users WHERE username = ?', ['john_doe']);
+```
+
+This avoids accidentally creating a new primary-key mapping for secondary identifiers while still returning results when mappings are unavailable.
+
 ### Security and Privacy
 
 **SHA-256 Hashing (Enabled by Default)**: Sensitive data like emails are hashed before being stored as KV keys, protecting user privacy:
@@ -908,28 +990,140 @@ for (const [table, pkColumn] of Object.entries(customIntegration)) {
 }
 ```
 
+## Cross-Shard Pagination Behavior
+
+`allAllShards` and `firstAllShards` execute the exact SQL on each shard independently. That means SQL `LIMIT`/`OFFSET` applies per shard, not globally.
+
+```typescript
+// With two shards, this can return up to 20 total rows (10 per shard)
+const perShard = await allAllShards('SELECT * FROM posts ORDER BY created_at DESC LIMIT 10');
+```
+
+If you need true global merge/sort/pagination across all shard results, use `allAllShardsGlobal` / `firstAllShardsGlobal` and pass sort/pagination options to the library:
+
+```typescript
+import { allAllShardsGlobal, firstAllShardsGlobal } from '@earth-app/collegedb';
+
+const page = await allAllShardsGlobal<{ id: string; created_at: number }>('SELECT id, created_at FROM posts', [], {
+	sortBy: 'created_at',
+	sortDirection: 'desc',
+	offset: 20,
+	limit: 10
+});
+
+const newest = await firstAllShardsGlobal<{ id: string; created_at: number }>('SELECT id, created_at FROM posts', [], {
+	sortBy: 'created_at',
+	sortDirection: 'desc'
+});
+```
+
+## Database Query Best Practices
+
+### Use Library Utility Operations for DDL and Inspection
+
+CollegeDB now exposes utility helpers for operational tasks that need shard awareness:
+
+```typescript
+import { countAllShards, explainAllShards, getDatabaseSizesAllShards, indexAllShards } from '@earth-app/collegedb';
+
+// Create index across all shards
+await indexAllShards('posts', [{ name: 'user_id' }, { name: 'created_at', order: 'DESC' }], {
+	ifNotExists: true
+});
+
+// Inspect query plan across all shards
+const plans = await explainAllShards('SELECT * FROM posts WHERE user_id = ? ORDER BY created_at DESC LIMIT 20', ['user-123']);
+
+// Count rows globally
+const counts = await countAllShards('posts');
+
+// Get per-shard size measurements
+const sizes = await getDatabaseSizesAllShards();
+```
+
+Recommended pattern:
+
+- Use `indexAllShards` for schema/index consistency.
+- Use `explain`/`explainAllShards` before adding indexes or changing query shapes.
+- Use `countAllShards` and `getDatabaseSizesAllShards` for operational dashboards and rebalancing thresholds.
+
+### Create Targeted Indexes
+
+```sql
+CREATE INDEX IF NOT EXISTS idx_posts_user_id_created_at ON posts(user_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_users_email ON users(email);
+```
+
+### Inspect Query Plans and Statistics
+
+```sql
+EXPLAIN QUERY PLAN SELECT * FROM posts WHERE user_id = ? ORDER BY created_at DESC LIMIT 20;
+PRAGMA optimize;
+ANALYZE;
+```
+
+### Use Bound Parameters (SQL Injection Protection)
+
+```typescript
+// Safe: parameterized query
+await first('user-123', 'SELECT * FROM users WHERE email = ?', [email]);
+
+// Avoid string interpolation with user input
+// BAD: `... WHERE email = '${email}'`
+```
+
+### Design Search for Scale
+
+- Exact-match or prefix search fields should be indexed.
+- Prefer bounded result sets (`LIMIT`) and stable sorting.
+- For global search pages, pair lightweight per-shard SQL with `allAllShardsGlobal` for final merge/sort/pagination.
+
+### Pagination Guidance
+
+- For routed single-key reads (`first`, `all`), SQL pagination is naturally shard-local and predictable.
+- For fanout (`allAllShards`, `firstAllShards`), SQL pagination is per-shard.
+- For user-facing global pages, use `allAllShardsGlobal` so offset/limit apply once after merge.
+
 ## API Reference
 
-| Function                                   | Description                                                      | Parameters                 |
-| ------------------------------------------ | ---------------------------------------------------------------- | -------------------------- |
-| `collegedb(config, callback)`              | Initialize CollegeDB, then run a callback                        | `CollegeDBConfig, () => T` |
-| `initialize(config)`                       | Initialize CollegeDB with configuration                          | `CollegeDBConfig`          |
-| `createSchema(db, schema)`                 | Create schema on a shard database                                | `SQLDatabase, string`      |
-| `prepare(key, sql)`                        | Prepare a SQL statement for execution                            | `string, string`           |
-| `run(key, sql, bindings)`                  | Execute a SQL query with primary key routing                     | `string, string, any[]`    |
-| `first(key, sql, bindings)`                | Execute a SQL query and return first result                      | `string, string, any[]`    |
-| `all(key, sql, bindings)`                  | Execute a SQL query and return all results                       | `string, string, any[]`    |
-| `runShard(shard, sql, bindings)`           | Execute a query directly on a specific shard                     | `string, string, any[]`    |
-| `allShard(shard, sql, bindings)`           | Execute a query on specific shard, return all results            | `string, string, any[]`    |
-| `firstShard(shard, sql, bindings)`         | Execute a query on specific shard, return first result           | `string, string, any[]`    |
-| `runAllShards(sql, bindings, batchSize)`   | Execute query on all shards                                      | `string, any[], number`    |
-| `allAllShards(sql, bindings, batchSize)`   | Execute query on all shards, return all results from all shards  | `string, any[], number`    |
-| `firstAllShards(sql, bindings, batchSize)` | Execute query on all shards, return first result from all shards | `string, any[], number`    |
-| `reassignShard(key, newShard)`             | Move primary key to different shard                              | `string, string`           |
-| `listKnownShards()`                        | Get list of available shards                                     | `void`                     |
-| `getShardStats()`                          | Get statistics for all shards                                    | `void`                     |
-| `getDatabaseSizeForShard(shard)`           | Get size of a specific shard in bytes                            | `string`                   |
-| `flush()`                                  | Clear all shard mappings (development only)                      | `void`                     |
+| Function                                          | Description                                                            | Parameters                                                         |
+| ------------------------------------------------- | ---------------------------------------------------------------------- | ------------------------------------------------------------------ |
+| `collegedb(config, callback)`                     | Initialize CollegeDB, then run a callback                              | `CollegeDBConfig, () => T`                                         |
+| `initialize(config)`                              | Initialize CollegeDB with configuration                                | `CollegeDBConfig`                                                  |
+| `createSchema(db, schema)`                        | Create schema on a shard database                                      | `SQLDatabase, string`                                              |
+| `prepare(key, sql)`                               | Prepare a SQL statement for execution                                  | `string, string`                                                   |
+| `run(key, sql, bindings)`                         | Execute a SQL query with primary key routing                           | `string, string, any[]`                                            |
+| `insert(sql, bindings)`                           | Insert on an automatically selected shard and capture the generated id | `string, any[]`                                                    |
+| `insertShard(shard, sql, bindings)`               | Insert directly on a specific shard and capture the generated id       | `string, string, any[]`                                            |
+| `first(key, sql, bindings)`                       | Execute a SQL query and return first result                            | `string, string, any[]`                                            |
+| `all(key, sql, bindings)`                         | Execute a SQL query and return all results                             | `string, string, any[]`                                            |
+| `index(key, table, columns, options)`             | Create an index on routed shard                                        | `string, string, string or index-column array, CreateIndexOptions` |
+| `indexShard(shard, table, columns, options)`      | Create an index on one shard                                           | `string, string, string or index-column array, CreateIndexOptions` |
+| `indexAllShards(table, columns, options)`         | Create an index on all shards                                          | `string, string or index-column array, CreateIndexOptions`         |
+| `firstByLookupKey(key, sql, bindings, batchSize)` | Resolve secondary-key mapping, fallback to fanout                      | `string, string, any[], number`                                    |
+| `allByLookupKey(key, sql, bindings, batchSize)`   | Resolve secondary-key mapping, fallback to fanout                      | `string, string, any[], number`                                    |
+| `runShard(shard, sql, bindings)`                  | Execute a query directly on a specific shard                           | `string, string, any[]`                                            |
+| `allShard(shard, sql, bindings)`                  | Execute a query on specific shard, return all results                  | `string, string, any[]`                                            |
+| `firstShard(shard, sql, bindings)`                | Execute a query on specific shard, return first result                 | `string, string, any[]`                                            |
+| `explain(key, sql, bindings, options)`            | Inspect query plan on routed shard                                     | `string, string, any[], ExplainOptions`                            |
+| `explainShard(shard, sql, bindings, options)`     | Inspect query plan on one shard                                        | `string, string, any[], ExplainOptions`                            |
+| `explainAllShards(sql, bindings, options)`        | Inspect query plan on all shards                                       | `string, any[], ExplainOptions`                                    |
+| `count(key, table)`                               | Count rows on routed shard                                             | `string, string`                                                   |
+| `countShard(shard, table)`                        | Count rows on a specific shard                                         | `string, string`                                                   |
+| `countAllShards(table, batchSize)`                | Count rows per shard and global total                                  | `string, number`                                                   |
+| `runAllShards(sql, bindings, batchSize)`          | Execute query on all shards                                            | `string, any[], number`                                            |
+| `allAllShards(sql, bindings, batchSize)`          | Execute query on all shards (SQL pagination applies per shard)         | `string, any[], number`                                            |
+| `firstAllShards(sql, bindings, batchSize)`        | Execute query on all shards, return first row per shard                | `string, any[], number`                                            |
+| `allAllShardsGlobal(sql, bindings, options)`      | Execute query on all shards, then globally merge/sort/paginate         | `string, any[], GlobalAllShardsOptions`                            |
+| `firstAllShardsGlobal(sql, bindings, options)`    | Return first row after global merge/sort/paginate                      | `string, any[], GlobalAllShardsOptions`                            |
+| `reassignShard(key, newShard)`                    | Move primary key to different shard                                    | `string, string`                                                   |
+| `listKnownShards()`                               | Get list of available shards                                           | `void`                                                             |
+| `getShardStats()`                                 | Get statistics for all shards                                          | `void`                                                             |
+| `getDatabaseSizeForKey(key)`                      | Get size of key-routed shard in bytes                                  | `string`                                                           |
+| `getDatabaseSizeForShard(shard)`                  | Get size of a specific shard in bytes                                  | `string`                                                           |
+| `getDatabaseSizesAllShards(batchSize)`            | Get per-shard size data                                                | `number`                                                           |
+| `getTotalDatabaseSize(batchSize)`                 | Get total size across all shards                                       | `number`                                                           |
+| `flush()`                                         | Clear all shard mappings (development only)                            | `void`                                                             |
 
 ### Provider Adapter Functions
 
@@ -1192,22 +1386,27 @@ const config: CollegeDBConfig = {
 
 CollegeDB exports TypeScript types for better development experience and type safety:
 
-| Type                    | Description                    | Example                                             |
-| ----------------------- | ------------------------------ | --------------------------------------------------- |
-| `CollegeDBConfig`       | Main configuration object      | `{ kv, shards, strategy }`                          |
-| `KVStorage`             | Provider-agnostic KV contract  | `createRedisKVProvider(redisClient)`                |
-| `SQLDatabase`           | Provider-agnostic SQL contract | `createPostgreSQLProvider(pgPool)`                  |
-| `NuxtHubKVLike`         | NuxtHub/Unstorage KV contract  | `createNuxtHubKVProvider(kv)`                       |
-| `DrizzleClientLike`     | Minimal Drizzle DB contract    | `createPostgreSQLProvider(drizzleDb, sql)`          |
-| `DrizzleSqlTagLike`     | Drizzle SQL tag contract       | `createSQLiteProvider(drizzleDb, sql)`              |
-| `QueryResult`           | Standard query response shape  | `{ success, results, meta }`                        |
-| `QueryResultMeta`       | Query execution metadata       | `{ duration, changes?, last_row_id? }`              |
-| `ShardingStrategy`      | Single strategy options        | `'hash' \| 'location' \| 'round-robin' \| 'random'` |
-| `MixedShardingStrategy` | Mixed strategy configuration   | `{ read: 'hash', write: 'location' }`               |
-| `OperationType`         | Database operation types       | `'read' \| 'write'`                                 |
-| `D1Region`              | Cloudflare D1 regions          | `'wnam' \| 'enam' \| 'weur' \| ...`                 |
-| `ShardLocation`         | Geographic shard configuration | `{ region: 'wnam', priority: 2 }`                   |
-| `ShardStats`            | Shard usage statistics         | `{ binding: 'db-east', count: 1542 }`               |
+| Type                    | Description                    | Example                                               |
+| ----------------------- | ------------------------------ | ----------------------------------------------------- |
+| `CollegeDBConfig`       | Main configuration object      | `{ kv, shards, strategy }`                            |
+| `KVStorage`             | Provider-agnostic KV contract  | `createRedisKVProvider(redisClient)`                  |
+| `SQLDatabase`           | Provider-agnostic SQL contract | `createPostgreSQLProvider(pgPool)`                    |
+| `NuxtHubKVLike`         | NuxtHub/Unstorage KV contract  | `createNuxtHubKVProvider(kv)`                         |
+| `DrizzleClientLike`     | Minimal Drizzle DB contract    | `createPostgreSQLProvider(drizzleDb, sql)`            |
+| `DrizzleSqlTagLike`     | Drizzle SQL tag contract       | `createSQLiteProvider(drizzleDb, sql)`                |
+| `QueryResult`           | Standard query response shape  | `{ success, results, meta }`                          |
+| `QueryResultMeta`       | Query execution metadata       | `{ duration, changes?, last_row_id? }`                |
+| `ShardingStrategy`      | Single strategy options        | `'hash' \| 'location' \| 'round-robin' \| 'random'`   |
+| `MixedShardingStrategy` | Mixed strategy configuration   | `{ read: 'hash', write: 'location' }`                 |
+| `OperationType`         | Database operation types       | `'read' \| 'write'`                                   |
+| `D1Region`              | Cloudflare D1 regions          | `'wnam' \| 'enam' \| 'weur' \| ...`                   |
+| `ShardLocation`         | Geographic shard configuration | `{ region: 'wnam', priority: 2 }`                     |
+| `ShardStats`            | Shard usage statistics         | `{ binding: 'db-east', count: 1542 }`                 |
+| `IndexColumnDefinition` | Index column definition        | `{ name: 'created_at', order: 'DESC' }`               |
+| `CreateIndexOptions`    | Index creation options         | `{ ifNotExists: true, unique: false }`                |
+| `ExplainOptions`        | Explain mode options           | `{ mode: 'query-plan' }`                              |
+| `ShardTableCount`       | Per-shard row-count result     | `{ shard: 'db-east', count: 100, success: true }`     |
+| `ShardSizeResult`       | Per-shard size result          | `{ shard: 'db-east', size: 10485760, success: true }` |
 
 #### Mixed Strategy Configuration
 

package/dist/index.d.ts

@@ -8,7 +8,8 @@
  * @author Gregory Mitchell
  * @license MIT
  */
-export { all, allAllShards, allShard, collegedb, createSchema, first, firstAllShards, firstShard, flush, getClosestRegionFromIP, getDatabaseSizeForShard, getShardStats, initialize, initializeAsync, listKnownShards, prepare, reassignShard, resetConfig, run, runAllShards, runShard } from './router';
+export { all, allAllShards, allAllShardsGlobal, allByLookupKey, allShard, collegedb, count, countAllShards, countShard, createSchema, explain, explainAllShards, explainShard, first, firstAllShards, firstAllShardsGlobal, firstByLookupKey, firstShard, flush, getClosestRegionFromIP, getDatabaseSizeForKey, getDatabaseSizeForShard, getDatabaseSizesAllShards, getShardStats, getTotalDatabaseSize, index, indexAllShards, indexShard, initialize, initializeAsync, insert, insertShard, listKnownShards, prepare, reassignShard, resetConfig, run, runAllShards, runShard } from './router';
+export type { CreateIndexOptions, ExplainOptions, GlobalAllShardsOptions, IndexColumnDefinition, InsertResult, ShardSizeResult, ShardTableCount } from './router';
 export { ShardCoordinator } from './durable';
 export { CollegeDBError } from './errors';
 export { KVShardMapper } from './kvmap';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EACN,GAAG,EACH,YAAY,EACZ,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,KAAK,EACL,cAAc,EACd,UAAU,EACV,KAAK,EACL,sBAAsB,EACtB,uBAAuB,EACvB,aAAa,EACb,UAAU,EACV,eAAe,EACf,eAAe,EACf,OAAO,EACP,aAAa,EACb,WAAW,EACX,GAAG,EACH,YAAY,EACZ,QAAQ,EACR,MAAM,UAAU,CAAC;AAGlB,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAGxC,OAAO,EACN,wBAAwB,EACxB,6BAA6B,EAC7B,gCAAgC,EAChC,mBAAmB,EACnB,uBAAuB,EACvB,wBAAwB,EACxB,qBAAqB,EACrB,oBAAoB,EACpB,sBAAsB,EACtB,WAAW,EACX,aAAa,EACb,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,4BAA4B,EACjC,KAAK,+BAA+B,EACpC,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACN,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,wBAAwB,EACxB,6BAA6B,EAC7B,wBAAwB,EACxB,2BAA2B,EAC3B,kCAAkC,EAClC,UAAU,EACV,yBAAyB,EACzB,UAAU,EACV,aAAa,EACb,YAAY,EACZ,wBAAwB,EACxB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,MAAM,cAAc,CAAC;AAGtB,YAAY,EACX,eAAe,EACf,QAAQ,EACR,GAAG,EACH,YAAY,EACZ,SAAS,EACT,qBAAqB,EACrB,aAAa,EACb,iBAAiB,EACjB,WAAW,EACX,eAAe,EACf,WAAW,EACX,qBAAqB,EACrB,aAAa,EACb,YAAY,EACZ,UAAU,EACV,gBAAgB,EAChB,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EACN,GAAG,EACH,YAAY,EACZ,kBAAkB,EAClB,cAAc,EACd,QAAQ,EACR,SAAS,EACT,KAAK,EACL,cAAc,EACd,UAAU,EACV,YAAY,EACZ,OAAO,EACP,gBAAgB,EAChB,YAAY,EACZ,KAAK,EACL,cAAc,EACd,oBAAoB,EACpB,gBAAgB,EAChB,UAAU,EACV,KAAK,EACL,sBAAsB,EACtB,qBAAqB,EACrB,uBAAuB,EACvB,yBAAyB,EACzB,aAAa,EACb,oBAAoB,EACpB,KAAK,EACL,cAAc,EACd,UAAU,EACV,UAAU,EACV,eAAe,EACf,MAAM,EACN,WAAW,EACX,eAAe,EACf,OAAO,EACP,aAAa,EACb,WAAW,EACX,GAAG,EACH,YAAY,EACZ,QAAQ,EACR,MAAM,UAAU,CAAC;AAElB,YAAY,EACX,kBAAkB,EAClB,cAAc,EACd,sBAAsB,EACtB,qBAAqB,EACrB,YAAY,EACZ,eAAe,EACf,eAAe,EACf,MAAM,UAAU,CAAC;AAGlB,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAGxC,OAAO,EACN,wBAAwB,EACxB,6BAA6B,EAC7B,gCAAgC,EAChC,mBAAmB,EACnB,uBAAuB,EACvB,wBAAwB,EACxB,qBAAqB,EACrB,oBAAoB,EACpB,sBAAsB,EACtB,WAAW,EACX,aAAa,EACb,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,4BAA4B,EACjC,KAAK,+BAA+B,EACpC,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACN,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,wBAAwB,EACxB,6BAA6B,EAC7B,wBAAwB,EACxB,2BAA2B,EAC3B,kCAAkC,EAClC,UAAU,EACV,yBAAyB,EACzB,UAAU,EACV,aAAa,EACb,YAAY,EACZ,wBAAwB,EACxB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,MAAM,cAAc,CAAC;AAGtB,YAAY,EACX,eAAe,EACf,QAAQ,EACR,GAAG,EACH,YAAY,EACZ,SAAS,EACT,qBAAqB,EACrB,aAAa,EACb,iBAAiB,EACjB,WAAW,EACX,eAAe,EACf,WAAW,EACX,qBAAqB,EACrB,aAAa,EACb,YAAY,EACZ,UAAU,EACV,gBAAgB,EAChB,MAAM,SAAS,CAAC"}