@minnowdb/core 0.7.5 → 0.7.8

package/dist/engine/schema.d.ts

@@ -1,5 +1,8 @@
 import { type ColumnDefault, type SqlDomain, type TableColumnRecord, type TableRecord } from "../storage/types.js";
+import type { ComparisonOperator } from "../plan/model.js";
+import type { BatchRow, BatchValue, InsertBatchInput } from "./batch.js";
 import { type Catalog, type CatalogColumn, type CatalogTable } from "./catalog.js";
+import type { DatabaseRow, DeleteBatchInput, UpdateBatchInput, UpsertOptions } from "./database.js";
 import { type Expression, type QueryValue } from "./query.js";
 /**
  * Typed schema DSL and catalog migration planning. Column builders carry compile-time value and
@@ -313,8 +316,8 @@ export declare function schema<TTables extends readonly AnyTable[], TViews exten
 }): SchemaDefinition<TTables, TViews>;
 type ColumnTypeMetadata<TColumn> = TColumn extends {
     readonly "~types"?: infer TMetadata extends {
-        readonly select: unknown;
-        readonly input: unknown;
+        readonly select: SchemaValue;
+        readonly input: SchemaValue;
     };
 } ? NonNullable<TMetadata> : never;
 type ColumnValue<TColumn extends AnyColumn> = TColumn["isNullable"] extends true ? ColumnTypeMetadata<TColumn>["select"] | null : ColumnTypeMetadata<TColumn>["select"];
@@ -359,6 +362,86 @@ export type PrimaryKeyKeys<TTable extends AnyTable> = {
 export type InferUpdateChanges<TTable extends AnyTable> = {
     [K in keyof TTable["columns"] as K extends PrimaryKeyKeys<TTable> | GeneratedKeys<TTable> ? never : K]?: ColumnInputValue<TTable["columns"][K]> | undefined;
 };
+/** The bound every schema type parameter carries. */
+export type AnySchema = SchemaDefinition<readonly AnyTable[]>;
+/**
+ * The schema type parameter's default: no declaration, so the batch API addresses tables by
+ * plain string. It is `any` rather than `AnySchema` so that a database declared against a schema
+ * remains assignable to the undeclared class — `MinnowDatabase<typeof mine>` is a
+ * `MinnowDatabase` — which no ordinary type argument can express once table names are checked.
+ * Every type below resolves to its erased branch for it, so nothing else about it is `any`.
+ */
+export type UntypedSchema = any;
+type SchemaTable<TSchema extends AnySchema> = TSchema["tables"][number];
+/** True when the schema carries no literal table names — the untyped default. */
+type ErasedSchema<TSchema extends AnySchema> = string extends SchemaTable<TSchema>["name"] ? true : false;
+/** The declared table names; `string` for an untyped database. */
+export type TableName<TSchema extends AnySchema> = SchemaTable<TSchema>["name"];
+/** The declaration behind one table name. */
+export type TableOf<TSchema extends AnySchema, TName extends TableName<TSchema>> = Extract<SchemaTable<TSchema>, {
+    readonly name: TName;
+}>;
+/** A declared table's column names; `string` for an untyped database. */
+export type BatchColumnName<TSchema extends AnySchema, TName extends TableName<TSchema>> = ErasedSchema<TSchema> extends true ? string : keyof TableOf<TSchema, TName>["columns"] & string;
+/** The columnar form of `InferInsertRow`: one vector per column, optional where the row is. */
+export interface ColumnarInsertBatch<TTable extends AnyTable> {
+    readonly columns: {
+        readonly [K in RequiredInsertKeys<TTable>]: ReadonlyArray<ColumnInputValue<TTable["columns"][K]>>;
+    } & {
+        readonly [K in OptionalInsertKeys<TTable>]?: ReadonlyArray<ColumnInputValue<TTable["columns"][K]>>;
+    };
+    /** Per row, whether the column was omitted (takes its default) rather than set to NULL. */
+    readonly omitted?: Partial<Readonly<Record<OptionalInsertKeys<TTable>, readonly boolean[]>>>;
+    readonly rowCount?: number;
+}
+/** What `insertBatch` and `upsertBatch` accept for one table: typed rows, or a typed columnar batch. */
+export type BatchInsertInput<TSchema extends AnySchema, TName extends TableName<TSchema>> = ErasedSchema<TSchema> extends true ? InsertBatchInput : ReadonlyArray<InferInsertRow<TableOf<TSchema, TName>>> | ColumnarInsertBatch<TableOf<TSchema, TName>>;
+/** One row for `insert`, `upsert`, or a buffered writer's `add`. */
+export type BatchInsertRow<TSchema extends AnySchema, TName extends TableName<TSchema>> = ErasedSchema<TSchema> extends true ? BatchRow : InferInsertRow<TableOf<TSchema, TName>>;
+/** What `readTable` returns per row. */
+export type BatchReadRow<TSchema extends AnySchema, TName extends TableName<TSchema>> = ErasedSchema<TSchema> extends true ? DatabaseRow : InferRow<TableOf<TSchema, TName>>;
+/**
+ * The key a batch write addresses a row by: the `.unique()` column or a one-column table-level
+ * primary key. A composite primary key is addressed through its hidden locator, which the batch
+ * API does not expose, so those tables get `never` here and are written through SQL instead.
+ */
+type BatchKey<TTable extends AnyTable> = TTable["primaryKey"] extends readonly [
+    unknown,
+    unknown,
+    ...unknown[]
+] ? never : TTable["primaryKey"] extends readonly [infer TOnly extends keyof TTable["columns"]] ? NonNullable<ColumnValue<TTable["columns"][TOnly]>> : NonNullable<ScalarUniqueKeyValue<TTable>>;
+/** One key value for `update` and `delete`. */
+export type BatchKeyValue<TSchema extends AnySchema, TName extends TableName<TSchema>> = ErasedSchema<TSchema> extends true ? Exclude<BatchValue, null> : BatchKey<TableOf<TSchema, TName>>;
+/** The changes object `update` takes: every non-key, non-generated column, each optional. */
+export type BatchUpdateChanges<TSchema extends AnySchema, TName extends TableName<TSchema>> = ErasedSchema<TSchema> extends true ? Readonly<Record<string, BatchValue>> : InferUpdateChanges<TableOf<TSchema, TName>>;
+/** What `updateBatch` takes: typed keys and one vector per changed column. */
+export type BatchUpdateInput<TSchema extends AnySchema, TName extends TableName<TSchema>> = ErasedSchema<TSchema> extends true ? UpdateBatchInput : {
+    readonly keys: ReadonlyArray<BatchKey<TableOf<TSchema, TName>>>;
+    readonly changes: {
+        readonly [K in keyof InferUpdateChanges<TableOf<TSchema, TName>>]?: ReadonlyArray<Exclude<InferUpdateChanges<TableOf<TSchema, TName>>[K], undefined>>;
+    };
+};
+/** What `deleteBatch` takes. */
+export type BatchDeleteInput<TSchema extends AnySchema, TName extends TableName<TSchema>> = ErasedSchema<TSchema> extends true ? DeleteBatchInput : {
+    readonly keys: ReadonlyArray<BatchKey<TableOf<TSchema, TName>>>;
+};
+/** A `conflictWhere` guard whose `value` follows the column it names. */
+export type BatchConflictWhere<TTable extends AnyTable> = {
+    [K in keyof TTable["columns"] & string]: {
+        readonly column: K;
+        readonly operator: ComparisonOperator;
+        readonly value: ColumnInputValue<TTable["columns"][K]>;
+    };
+}[keyof TTable["columns"] & string];
+/** `upsertBatch`/`upsert` options, with the guard typed against the table. */
+export type BatchUpsertOptions<TSchema extends AnySchema, TName extends TableName<TSchema>> = ErasedSchema<TSchema> extends true ? UpsertOptions : {
+    readonly conflictWhere?: BatchConflictWhere<TableOf<TSchema, TName>>;
+};
+/** `readTable` options; naming `columns` narrows the returned rows to those columns. */
+export interface BatchReadOptions<TSchema extends AnySchema, TName extends TableName<TSchema>, TColumns extends ReadonlyArray<BatchColumnName<TSchema, TName>> = ReadonlyArray<BatchColumnName<TSchema, TName>>> {
+    readonly version?: number;
+    readonly columns?: TColumns;
+}
 export type MigrationStep = {
     kind: "create-table";
     table: AnyTable;

package/dist/engine/worker-server.js

@@ -554,10 +554,13 @@ class DatabaseRpcServer {
       return handle.session.execute(sql, params);
     }
     if (method === "stage") {
-      const [op, tableName, input] = args;
+      const [op, tableName, input, options] = args;
       if (!isStageOp(op)) {
         throw new Error(`Unsupported write stage operation: ${String(op)}`);
       }
+      if (op === "upsertBatch") {
+        return handle.session.upsertBatch(tableName, input, options);
+      }
       return handle.session[op](tableName, input);
     }
     if (method === "commit")

package/dist/storage/indexeddb.js

@@ -3919,7 +3919,12 @@ class IndexedDbBlockStore {
         await assertActiveGarbageCollectionMarker(gcStore, current);
       }
       const updated = updateGarbageCollectionPlanningRecord(current, input);
-      await assertGarbageCollectionCandidateProvenanceInTransaction(transaction, updated);
+      await assertGarbageCollectionCandidateProvenanceInTransaction(transaction, {
+        candidateManifestVersions: input.candidateManifestVersions ?? [],
+        candidateSegmentIds: input.candidateSegmentIds ?? [],
+        candidateBlockIds: input.candidateBlockIds ?? [],
+        candidateTransactionIds: input.candidateTransactionIds ?? []
+      });
       gcStore.put(garbageCollectionJobEnvelope(updated), key);
       await transactionDone(transaction);
       return structuredClone(updated);
@@ -9717,15 +9722,15 @@ function assertGenericTransactionUpdateAllowed(record, update) {
     throw new TypeError("Only commitTransaction can set a committed transaction version");
   }
 }
-async function assertGarbageCollectionCandidateProvenanceInTransaction(transaction, job) {
+async function assertGarbageCollectionCandidateProvenanceInTransaction(transaction, candidates) {
   const manifestStore = transaction.objectStore("manifests");
-  for (const version of job.candidateManifestVersions) {
+  for (const version of candidates.candidateManifestVersions) {
     const value = await requestResult(manifestStore.get(version));
     if (value === void 0) {
       throw new Error(`Garbage collection candidate manifest is missing: ${String(version)}`);
     }
   }
-  for (const id of job.candidateTransactionIds) {
+  for (const id of candidates.candidateTransactionIds) {
     const value = await requestResult(transaction.objectStore("transactions").get(id));
     const record = value === void 0 ? void 0 : asTransactionRecord(value);
     if (record === void 0 || record.status !== "aborted" && (record.status !== "committed" || record.committedVersion === null)) {
@@ -9733,10 +9738,10 @@ async function assertGarbageCollectionCandidateProvenanceInTransaction(transacti
     }
   }
   const manifestProvenBlockIds = /* @__PURE__ */ new Set();
-  const manifestValues = await Promise.all(job.candidateBlockIds.map((id) => requestResult(transaction.objectStore("catalog").get(manifestBlockKey(id)))));
+  const manifestValues = await Promise.all(candidates.candidateBlockIds.map((id) => requestResult(transaction.objectStore("catalog").get(manifestBlockKey(id)))));
   for (const [index, value] of manifestValues.entries()) {
     if (value !== void 0) {
-      const id = job.candidateBlockIds[index] ?? "";
+      const id = candidates.candidateBlockIds[index] ?? "";
       asManifestBlockRecord(value, id);
       manifestProvenBlockIds.add(id);
     }
@@ -9757,12 +9762,12 @@ async function assertGarbageCollectionCandidateProvenanceInTransaction(transacti
       return isTerminalCompactionJob(record) && (record.sourceBlockIds.includes(id) || record.outputBlockIds.includes(id));
     });
   };
-  for (const id of job.candidateBlockIds) {
+  for (const id of candidates.candidateBlockIds) {
     if (await blockHasProvenance(id))
       continue;
     throw new Error(`Garbage collection block candidate has no persisted provenance: ${id}`);
   }
-  for (const id of job.candidateSegmentIds) {
+  for (const id of candidates.candidateSegmentIds) {
     const segmentValue = await requestResult(transaction.objectStore("segments").get(id));
     if (segmentValue !== void 0)
       continue;

package/dist/storage/toolkit/record-core.js

@@ -3567,7 +3567,12 @@ class RecordCore {
       throw new GarbageCollectionJobConflictError(input.jobId, input.expectedRevision, current?.revision ?? null);
     }
     const updated = updateGarbageCollectionPlanningRecord(current, input);
-    assertGarbageCollectionCandidateProvenance(updated, this.#manifests, this.#manifestBlocks, this.#segments, this.#transactions, this.#roots);
+    assertGarbageCollectionCandidateProvenance({
+      candidateManifestVersions: input.candidateManifestVersions ?? [],
+      candidateSegmentIds: input.candidateSegmentIds ?? [],
+      candidateBlockIds: input.candidateBlockIds ?? [],
+      candidateTransactionIds: input.candidateTransactionIds ?? []
+    }, this.#manifests, this.#manifestBlocks, this.#segments, this.#transactions, this.#roots);
     this.#garbageCollectionJobs.set(updated.id, updated);
     return cloneRecord(updated);
   }
@@ -5661,23 +5666,23 @@ function assertPendingArtifactsAvailable(transaction, physical, segments, valida
     }
   }
 }
-function assertGarbageCollectionCandidateProvenance(job, manifests, manifestBlocks, segments, transactions, roots) {
-  for (const version of job.candidateManifestVersions) {
+function assertGarbageCollectionCandidateProvenance(candidates, manifests, manifestBlocks, segments, transactions, roots) {
+  for (const version of candidates.candidateManifestVersions) {
     if (!manifests.has(version)) {
       throw new Error(`Garbage collection candidate manifest is missing: ${String(version)}`);
     }
   }
-  for (const id of job.candidateTransactionIds) {
+  for (const id of candidates.candidateTransactionIds) {
     const transaction = transactions.get(id);
     if (transaction === void 0 || transaction.status !== "aborted" && (transaction.status !== "committed" || transaction.committedVersion === null)) {
       throw new Error(`Garbage collection transaction candidate is not terminal: ${id}`);
     }
   }
-  const unprovenBlockId = job.candidateBlockIds.find((id) => !manifestBlocks.has(id) && roots.abortedTransactionBlockCount(id) === 0 && roots.terminalJobBlockCount(id) === 0);
+  const unprovenBlockId = candidates.candidateBlockIds.find((id) => !manifestBlocks.has(id) && roots.abortedTransactionBlockCount(id) === 0 && roots.terminalJobBlockCount(id) === 0);
   if (unprovenBlockId !== void 0) {
     throw new Error(`Garbage collection block candidate has no persisted provenance: ${unprovenBlockId}`);
   }
-  const unprovenSegmentId = job.candidateSegmentIds.find((id) => {
+  const unprovenSegmentId = candidates.candidateSegmentIds.find((id) => {
     return !segments.has(id);
   });
   if (unprovenSegmentId !== void 0) {

package/dist/storage/types.d.ts

@@ -815,6 +815,17 @@ export interface UpdateGarbageCollectionPlanningInput {
     discovery: GarbageCollectionDiscovery;
     updatedAt: string;
 }
+/**
+ * One page's (or one job's full) proposed garbage-collection candidates, checked for persisted
+ * provenance before being accepted. Shared by every adapter's provenance assertion so a candidate
+ * kind added to one cannot be forgotten in another.
+ */
+export interface GarbageCollectionCandidateSet {
+    readonly candidateManifestVersions: readonly number[];
+    readonly candidateSegmentIds: readonly string[];
+    readonly candidateBlockIds: readonly string[];
+    readonly candidateTransactionIds: readonly string[];
+}
 export interface GarbageCollectionJobRecord {
     id: string;
     candidateManifestVersions: number[];

package/dist/worker-protocol/index.d.ts

@@ -1,4 +1,4 @@
-export declare const protocolVersion: 3;
+export declare const protocolVersion: 4;
 /** Outstanding request/response pairs retained by either side of one database RPC connection. */
 export declare const MAX_DATABASE_RPC_IN_FLIGHT = 256;
 export type RpcRequest = {

package/dist/worker-protocol/index.js

@@ -1,4 +1,4 @@
-const protocolVersion = 3;
+const protocolVersion = 4;
 const MAX_DATABASE_RPC_IN_FLIGHT = 256;
 function serializeError(error) {
   if (!(error instanceof Error)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minnowdb/core",
-  "version": "0.7.5",
+  "version": "0.7.8",
   "description": "A columnar SQL database for the browser: PostgreSQL-style SQL over durable IndexedDB or OPFS data, with no server or WebAssembly module.",
   "license": "MIT",
   "author": "Eric Wilhite",