@firtoz/drizzle-durable-sqlite 2.0.0 → 2.1.0

package/dist/drizzle-partial-sync-store.d.ts

@@ -0,0 +1,22 @@
+import { PartialSyncRowShape, PartialSyncServerBridgeStore } from '@firtoz/collection-sync';
+import { InferSelectModel } from 'drizzle-orm';
+import { SQLiteTable } from 'drizzle-orm/sqlite-core';
+import { DrizzleChangelogHelper } from './drizzle-partial-sync-changelog.js';
+import { PartialSyncSqliteDatabase } from './partial-sync-sqlite-db.js';
+import { PartialSyncTableConfig } from './partial-sync-predicate-sql.js';
+import 'drizzle-orm/durable-sqlite';
+
+type CreateDrizzlePartialSyncStoreOptions<TSchema extends Record<string, unknown>, TRow extends PartialSyncRowShape> = {
+    db: PartialSyncSqliteDatabase<TSchema>;
+    table: SQLiteTable;
+    columnConfig: PartialSyncTableConfig;
+    changelogHelper: DrizzleChangelogHelper<TSchema>;
+    deserializeJson: (raw: string) => unknown;
+    /** Column name on `table` used for `changesSince` watermark (e.g. `updatedAt`). */
+    updatedAtColumnName: keyof TRow & string;
+};
+declare function createDrizzlePartialSyncStore<TSchema extends Record<string, unknown>, TRow extends PartialSyncRowShape>(options: CreateDrizzlePartialSyncStoreOptions<TSchema, TRow>): PartialSyncServerBridgeStore<TRow>;
+/** Infer row type from a Drizzle SQLite table. */
+type InferPartialSyncRow<TTable extends SQLiteTable> = InferSelectModel<TTable>;
+
+export { type CreateDrizzlePartialSyncStoreOptions, type InferPartialSyncRow, createDrizzlePartialSyncStore };

package/dist/drizzle-partial-sync-store.js

@@ -0,0 +1,4 @@
+export { createDrizzlePartialSyncStore } from './chunk-JHZRO76J.js';
+import './chunk-QHM6T5OI.js';
+//# sourceMappingURL=drizzle-partial-sync-store.js.map
+//# sourceMappingURL=drizzle-partial-sync-store.js.map

package/dist/drizzle-partial-sync-store.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"drizzle-partial-sync-store.js"}

package/dist/durable-sqlite-collection.d.ts

@@ -0,0 +1,41 @@
+import { SyncMode, CollectionConfig, InferSchemaOutput } from '@tanstack/db';
+import { Table } from 'drizzle-orm';
+import { DrizzleSqliteDODatabase } from 'drizzle-orm/durable-sqlite';
+import { CollectionUtils } from '@firtoz/db-helpers';
+import { TableWithRequiredFields, SQLInterceptor, SelectSchema, IdOf, InsertToSelectSchema } from '@firtoz/drizzle-utils';
+export { SQLInterceptor, SQLOperation } from '@firtoz/drizzle-utils';
+
+/**
+ * Drizzle database type for `drizzle-orm/durable-sqlite` (Cloudflare DO SQLite).
+ */
+type AnyDurableSqliteDatabase = DrizzleSqliteDODatabase<Record<string, unknown>>;
+type DurableDrizzleSchema<TDrizzle extends AnyDurableSqliteDatabase> = TDrizzle["_"]["fullSchema"];
+interface DurableSqliteCollectionConfig<TDrizzle extends AnyDurableSqliteDatabase, TTableName extends ValidTableNames<DurableDrizzleSchema<TDrizzle>>> {
+    drizzle: TDrizzle;
+    tableName: ValidTableNames<DurableDrizzleSchema<TDrizzle>> extends never ? {
+        $error: "The schema needs to include at least one table that uses the syncableTable function.";
+    } : TTableName;
+    /**
+     * Await before running sync queries (e.g. migrations finishing). Omit or leave undefined to use an already-resolved promise (no extra wait).
+     */
+    readyPromise?: Promise<void>;
+    syncMode?: SyncMode;
+    debug?: boolean;
+    interceptor?: SQLInterceptor;
+}
+type ValidTableNames<TSchema extends Record<string, unknown>> = {
+    [K in keyof TSchema]: TSchema[K] extends TableWithRequiredFields ? K : never;
+}[keyof TSchema];
+type DurableSqliteCollectionConfigResult<TTable extends Table> = Omit<CollectionConfig<InferSchemaOutput<SelectSchema<TTable>>, IdOf<TTable>, InsertToSelectSchema<TTable>, CollectionUtils<InferSchemaOutput<SelectSchema<TTable>>>>, "utils"> & {
+    schema: InsertToSelectSchema<TTable>;
+    utils: CollectionUtils<InferSchemaOutput<SelectSchema<TTable>>>;
+};
+/**
+ * TanStack DB collection configuration for a table stored in Durable Object SQLite via Drizzle.
+ *
+ * Uses `driverMode: "sync"` internally: DO SQLite runs `transactionSync`, so mutations use
+ * `.all()` / `.run()` inside a synchronous transaction callback (see `createSqliteTableSyncBackend` in `@firtoz/drizzle-utils`).
+ */
+declare function durableSqliteCollectionOptions<const TDrizzle extends AnyDurableSqliteDatabase, const TTableName extends string & ValidTableNames<DurableDrizzleSchema<TDrizzle>>, TTable extends DurableDrizzleSchema<TDrizzle>[TTableName] & TableWithRequiredFields>(config: DurableSqliteCollectionConfig<TDrizzle, TTableName>): DurableSqliteCollectionConfigResult<TTable>;
+
+export { type AnyDurableSqliteDatabase, type DurableDrizzleSchema, type DurableSqliteCollectionConfig, type DurableSqliteCollectionConfigResult, type ValidTableNames, durableSqliteCollectionOptions };

package/dist/durable-sqlite-collection.js

@@ -0,0 +1,3 @@
+export { durableSqliteCollectionOptions } from './chunk-YA4MAETI.js';
+//# sourceMappingURL=durable-sqlite-collection.js.map
+//# sourceMappingURL=durable-sqlite-collection.js.map

package/dist/durable-sqlite-collection.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"durable-sqlite-collection.js"}

package/dist/durable-sqlite-sync-server.d.ts

@@ -0,0 +1,48 @@
+import { SyncMessage } from '@firtoz/db-helpers';
+
+type MutationIntent<TItem> = {
+    clientMutationId: string;
+    type: "insert";
+    value: TItem;
+} | {
+    clientMutationId: string;
+    type: "update";
+    key: string | number;
+    value: TItem;
+    previousValue: TItem;
+} | {
+    clientMutationId: string;
+    type: "delete";
+    key: string | number;
+} | {
+    clientMutationId: string;
+    type: "truncate";
+};
+interface DurableCollectionLike<TItem> {
+    insert: (item: Partial<TItem>) => {
+        isPersisted: {
+            promise: Promise<void>;
+        };
+    };
+    update: (key: string | number, updater: (draft: TItem) => void) => {
+        isPersisted: {
+            promise: Promise<void>;
+        };
+    };
+    delete: (key: string | number) => {
+        isPersisted: {
+            promise: Promise<void>;
+        };
+    };
+    utils: {
+        truncate: () => Promise<void>;
+    };
+}
+declare function applyDurableMutationIntents<TItem extends {
+    id: string | number;
+}>(collection: DurableCollectionLike<TItem>, intents: MutationIntent<TItem>[]): Promise<{
+    changes: SyncMessage<TItem>[];
+    acceptedMutationIds: string[];
+}>;
+
+export { type DurableCollectionLike, applyDurableMutationIntents };

package/dist/durable-sqlite-sync-server.js

@@ -0,0 +1,3 @@
+export { applyDurableMutationIntents } from './chunk-NJ7RJSGZ.js';
+//# sourceMappingURL=durable-sqlite-sync-server.js.map
+//# sourceMappingURL=durable-sqlite-sync-server.js.map

package/dist/durable-sqlite-sync-server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"durable-sqlite-sync-server.js"}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+export { AnyDurableSqliteDatabase, DurableDrizzleSchema, DurableSqliteCollectionConfig, DurableSqliteCollectionConfigResult, ValidTableNames, durableSqliteCollectionOptions } from './durable-sqlite-collection.js';
+export { DurableCollectionLike, applyDurableMutationIntents } from './durable-sqlite-sync-server.js';
+export { SyncableDurableObject, SyncableDurableObjectConfig, SyncableDurableObjectSyncRow } from './syncable-durable-object.js';
+export { QueryableDurableObject, QueryableDurableObjectConfig } from './queryable-durable-object.js';
+export { ChangelogOperation, DrizzleChangelogHelper, DrizzleChangelogHelperOptions, createDrizzleChangelogHelper } from './drizzle-partial-sync-changelog.js';
+export { PartialSyncSqliteDatabase } from './partial-sync-sqlite-db.js';
+export { CreateDrizzleMutationStoreOptions, createDrizzleMutationStore } from './drizzle-mutation-store.js';
+export { CreateDrizzlePartialSyncStoreOptions, InferPartialSyncRow, createDrizzlePartialSyncStore } from './drizzle-partial-sync-store.js';
+export { PartialSyncColumnKind, PartialSyncTableColumnConfig, PartialSyncTableConfig, coercePredicateScalar, columnRefForPredicate, predicateWhereFromConditions, rangeConditionToSQL, sortColumnFromConfig } from './partial-sync-predicate-sql.js';
+export { SQLInterceptor, SQLOperation } from '@firtoz/drizzle-utils';
+import '@tanstack/db';
+import 'drizzle-orm';
+import 'drizzle-orm/durable-sqlite';
+import '@firtoz/db-helpers';
+import 'hono/hono-base';
+import 'hono/utils/http-status';
+import '@firtoz/collection-sync';
+import 'drizzle-orm/durable-sqlite/migrator';
+import '@firtoz/websocket-do';
+import 'drizzle-orm/sqlite-core';

package/dist/index.js

@@ -0,0 +1,10 @@
+export { QueryableDurableObject } from './chunk-3XAF3IZW.js';
+export { SyncableDurableObject } from './chunk-ONDKTPGP.js';
+export { createDrizzleMutationStore } from './chunk-PA5TYHIW.js';
+export { createDrizzleChangelogHelper } from './chunk-DTRYQ3SF.js';
+export { createDrizzlePartialSyncStore } from './chunk-JHZRO76J.js';
+export { durableSqliteCollectionOptions } from './chunk-YA4MAETI.js';
+export { applyDurableMutationIntents } from './chunk-NJ7RJSGZ.js';
+export { coercePredicateScalar, columnRefForPredicate, predicateWhereFromConditions, rangeConditionToSQL, sortColumnFromConfig } from './chunk-QHM6T5OI.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/partial-sync-predicate-sql.d.ts

@@ -0,0 +1,29 @@
+import { RangeCondition } from '@firtoz/collection-sync';
+import { SQL } from 'drizzle-orm';
+import { SQLiteTable, SQLiteColumn } from 'drizzle-orm/sqlite-core';
+
+/** Column kind for predicate coercion and sort. */
+type PartialSyncColumnKind = "text" | "integer";
+type PartialSyncTableColumnConfig = {
+    kind: PartialSyncColumnKind;
+    /**
+     * When kind is `integer`, use `Math.trunc` after `Number()` (grid coordinates).
+     * Default false: finite number only.
+     */
+    truncateInteger?: boolean;
+};
+/**
+ * Declares which table columns exist for predicates/sorts and how to coerce literals.
+ * `sortableColumns` must be a subset of keys in `columns`.
+ */
+type PartialSyncTableConfig<TSortable extends string = string> = {
+    columns: Record<string, PartialSyncTableColumnConfig>;
+    sortableColumns: readonly TSortable[];
+};
+declare function columnRefForPredicate(table: SQLiteTable, columnName: string, columnConfig: PartialSyncTableConfig): SQLiteColumn;
+declare function coercePredicateScalar(column: string, value: unknown, columnConfig: PartialSyncTableConfig): string | number;
+declare function rangeConditionToSQL(table: SQLiteTable, condition: RangeCondition, columnConfig: PartialSyncTableConfig): SQL;
+declare function predicateWhereFromConditions(table: SQLiteTable, conditions: RangeCondition[], columnConfig: PartialSyncTableConfig): SQL | undefined;
+declare function sortColumnFromConfig(table: SQLiteTable, columnName: string, columnConfig: PartialSyncTableConfig): SQLiteColumn;
+
+export { type PartialSyncColumnKind, type PartialSyncTableColumnConfig, type PartialSyncTableConfig, coercePredicateScalar, columnRefForPredicate, predicateWhereFromConditions, rangeConditionToSQL, sortColumnFromConfig };

package/dist/partial-sync-predicate-sql.js

@@ -0,0 +1,3 @@
+export { coercePredicateScalar, columnRefForPredicate, predicateWhereFromConditions, rangeConditionToSQL, sortColumnFromConfig } from './chunk-QHM6T5OI.js';
+//# sourceMappingURL=partial-sync-predicate-sql.js.map
+//# sourceMappingURL=partial-sync-predicate-sql.js.map

package/dist/partial-sync-predicate-sql.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"partial-sync-predicate-sql.js"}

package/dist/partial-sync-sqlite-db.d.ts

@@ -0,0 +1,9 @@
+import { DrizzleSqliteDODatabase } from 'drizzle-orm/durable-sqlite';
+
+/**
+ * Drizzle Durable Object SQLite database used by partial-sync helpers.
+ * (Bun/libsql drivers differ in `select` overloads; use DO SQLite in Workers.)
+ */
+type PartialSyncSqliteDatabase<TSchema extends Record<string, unknown>> = DrizzleSqliteDODatabase<TSchema>;
+
+export type { PartialSyncSqliteDatabase };

package/dist/partial-sync-sqlite-db.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=partial-sync-sqlite-db.js.map
+//# sourceMappingURL=partial-sync-sqlite-db.js.map

package/dist/partial-sync-sqlite-db.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"partial-sync-sqlite-db.js"}

package/dist/queryable-durable-object.d.ts

@@ -0,0 +1,128 @@
+import * as hono_hono_base from 'hono/hono-base';
+import * as hono_utils_http_status from 'hono/utils/http-status';
+import { PartialSyncRowShape, SyncServerMessage, SyncClientMessage, PartialSyncServerBridge, PartialSyncMutationHandler, PartialSyncServerBridgeStore, RangeCondition, SyncRange, SyncRangeSort, SyncServerBridgeStore } from '@firtoz/collection-sync';
+import { SyncMessage } from '@firtoz/db-helpers';
+import { StandardSchemaWebSocketDO, StandardSchemaSession, StandardSchemaSessionOptions } from '@firtoz/websocket-do';
+import { drizzle, DrizzleSqliteDODatabase } from 'drizzle-orm/durable-sqlite';
+import { migrate } from 'drizzle-orm/durable-sqlite/migrator';
+
+type SessionData = {
+    clientId: string;
+};
+type MutationSyncRow = PartialSyncRowShape;
+type SessionDispatch<TRow extends MutationSyncRow> = {
+    partialBridge: PartialSyncServerBridge<TRow>;
+    partialMutationHandler?: PartialSyncMutationHandler<TRow>;
+};
+type SessionSlot<TRow extends MutationSyncRow> = {
+    dispatch?: SessionDispatch<TRow>;
+    pending: SyncClientMessage[];
+};
+declare class QueryableSession<TItem extends PartialSyncRowShape, TEnv extends Cloudflare.Env> extends StandardSchemaSession<SessionData, SyncServerMessage<TItem>, SyncClientMessage, TEnv> {
+    private readonly sessionSlot;
+    clientId: string;
+    constructor(websocket: WebSocket, sessions: Map<WebSocket, QueryableSession<TItem, TEnv>>, options: StandardSchemaSessionOptions<SyncClientMessage, SyncServerMessage<TItem>>, sessionSlot: SessionSlot<TItem>);
+}
+type QueryableDurableObjectConfig<TSchema extends Record<string, unknown>, TRow extends PartialSyncRowShape = PartialSyncRowShape> = {
+    schema: TSchema;
+    migrations: Parameters<typeof migrate>[1];
+    queryChunkSize?: number;
+    seedInBackground?: boolean;
+    serializeJson?: (value: unknown) => string;
+    deserializeJson?: (raw: string) => unknown;
+    /**
+     * When set, used as the partial-sync store instead of overriding
+     * {@link QueryableDurableObject.queryRange}, {@link QueryableDurableObject.queryByOffset},
+     * and {@link QueryableDurableObject.getTotalCount}.
+     */
+    createPartialSyncStore?: (db: DrizzleSqliteDODatabase<TSchema>) => PartialSyncServerBridgeStore<TRow>;
+    /**
+     * Multiplex key for partial-sync WebSocket messages.
+     * When using {@link PartialSyncMutationHandler} on the same socket, use the same id unless you multiplex multiple collections.
+     */
+    collectionId?: string;
+    /**
+     * Server-side narrowing of client predicate viewports (e.g. fog of war). Passed to
+     * {@link PartialSyncServerBridge}.
+     */
+    resolveClientVisibility?: (clientId: string, requestedConditions: RangeCondition[]) => RangeCondition[] | Promise<RangeCondition[]>;
+    /**
+     * Optional hints for rows that left the client's range during `rangeReconcile`. Return `null` for
+     * fog of war (default when omitted).
+     */
+    resolveMovedHint?: (row: TRow, range: SyncRange) => Record<string, unknown> | null | Promise<Record<string, unknown> | null>;
+};
+declare abstract class QueryableDurableObject<TRow extends PartialSyncRowShape, TSchema extends Record<string, unknown>, TEnv extends Cloudflare.Env = Cloudflare.Env> extends StandardSchemaWebSocketDO<QueryableSession<TRow, TEnv>, SyncClientMessage, SyncServerMessage<TRow>, TEnv> {
+    protected db: ReturnType<typeof drizzle>;
+    protected bridge: PartialSyncServerBridge<TRow>;
+    protected partialMutationHandler?: PartialSyncMutationHandler<TRow>;
+    readonly app: hono_hono_base.HonoBase<{
+        Bindings: TEnv;
+    }, {
+        "/websocket": {
+            $get: {
+                input: {};
+                output: {};
+                outputFormat: string;
+                status: hono_utils_http_status.StatusCode;
+            };
+        };
+    } & {
+        "/health": {
+            $get: {
+                input: {};
+                output: "ok";
+                outputFormat: "text";
+                status: hono_utils_http_status.ContentfulStatusCode;
+            };
+        };
+    }, "/", "/health">;
+    constructor(ctx: DurableObjectState, env: TEnv, config: QueryableDurableObjectConfig<TSchema, TRow>);
+    protected queryRange(_options: {
+        sort: {
+            column: string;
+            direction: "asc" | "desc";
+        };
+        limit: number;
+        afterCursor: unknown | null;
+        chunkSize: number;
+    }): AsyncIterable<TRow[]>;
+    protected queryByOffset(_options: {
+        sort: {
+            column: string;
+            direction: "asc" | "desc";
+        };
+        limit: number;
+        offset: number;
+        chunkSize: number;
+    }): AsyncIterable<TRow[]>;
+    protected getTotalCount(): Promise<number>;
+    protected queryByPredicate?(_options: {
+        conditions: RangeCondition[];
+        sort?: SyncRangeSort;
+        limit?: number;
+        chunkSize: number;
+    }): AsyncIterable<TRow[]>;
+    protected getPredicateCount?(_conditions: RangeCondition[]): Promise<number>;
+    protected changesSince?(_options: {
+        range: SyncRange;
+        sinceVersion: number;
+        chunkSize: number;
+    }): Promise<{
+        changes: SyncMessage<TRow>[];
+        totalCount: number;
+    } | null>;
+    protected getSortValue(row: TRow, column: string): unknown;
+    /**
+     * When overridden to return a store, `mutateBatch` is handled by {@link PartialSyncMutationHandler}
+     * (interest-scoped `rangePatch` + `ack` with `serverVersion: 0`). `syncHello` is not handled on this path.
+     * Range traffic stays on {@link PartialSyncServerBridge}.
+     */
+    protected createClientMutationSyncStore(): SyncServerBridgeStore<TRow> | undefined;
+    protected seedData(): Promise<void>;
+    pushServerChanges(changes: SyncMessage<TRow>[]): Promise<void>;
+    protected sendToClient(clientId: string, message: SyncServerMessage<TRow>): void;
+    protected broadcastExcept(excludeClientId: string, message: SyncServerMessage<TRow>): void;
+}
+
+export { QueryableDurableObject, type QueryableDurableObjectConfig };

package/dist/queryable-durable-object.js

@@ -0,0 +1,3 @@
+export { QueryableDurableObject } from './chunk-3XAF3IZW.js';
+//# sourceMappingURL=queryable-durable-object.js.map
+//# sourceMappingURL=queryable-durable-object.js.map

package/dist/queryable-durable-object.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"queryable-durable-object.js"}

package/dist/syncable-durable-object.d.ts

@@ -0,0 +1,58 @@
+import * as hono_hono_base from 'hono/hono-base';
+import * as hono_utils_http_status from 'hono/utils/http-status';
+import { SyncClientMessage, SyncServerMessage, SyncServerBridge, PartialSyncRowShape } from '@firtoz/collection-sync';
+import { InferSchemaOutput, SyncMode } from '@tanstack/db';
+import { migrate } from 'drizzle-orm/durable-sqlite/migrator';
+import { TableWithRequiredFields, SelectSchema, DrizzleSqliteTableCollection } from '@firtoz/drizzle-utils';
+import { StandardSchemaWebSocketDO } from '@firtoz/websocket-do';
+import { ValidTableNames } from './durable-sqlite-collection.js';
+import 'drizzle-orm';
+import 'drizzle-orm/durable-sqlite';
+import '@firtoz/db-helpers';
+
+/**
+ * Drizzle/Valibot `InferSchemaOutput` is not always structurally assignable to
+ * {@link PartialSyncRowShape}. Intersecting keeps inferred columns while requiring sync row keys for
+ * {@link SyncServerBridge}.
+ */
+type SyncBridgeRowFromTable<TTable extends TableWithRequiredFields> = InferSchemaOutput<SelectSchema<TTable>> & PartialSyncRowShape;
+type SyncableDurableObjectSyncRow<TSchema extends Record<string, unknown>, TTableName extends ValidTableNames<TSchema>> = SyncBridgeRowFromTable<TSchema[TTableName] & TableWithRequiredFields>;
+type SyncableDurableObjectConfig<TSchema extends Record<string, unknown>, TTableName extends ValidTableNames<TSchema>> = {
+    schema: TSchema;
+    tableName: TTableName;
+    migrations: Parameters<typeof migrate>[1];
+    syncMode?: SyncMode;
+    serializeJson?: (value: unknown) => string;
+    deserializeJson?: (raw: string) => unknown;
+};
+/**
+ * Durable Object base class: Drizzle SQLite + {@link SyncServerBridge} + WebSocket sessions.
+ */
+declare abstract class SyncableDurableObject<TSchema extends Record<string, unknown>, TTableName extends ValidTableNames<TSchema>, TEnv extends Cloudflare.Env = Cloudflare.Env> extends StandardSchemaWebSocketDO<any, SyncClientMessage, SyncServerMessage<unknown>, TEnv> {
+    protected bridge: SyncServerBridge<SyncableDurableObjectSyncRow<TSchema, TTableName>>;
+    protected collection: DrizzleSqliteTableCollection<TSchema[TTableName] & TableWithRequiredFields>;
+    readonly app: hono_hono_base.HonoBase<{
+        Bindings: TEnv;
+    }, {
+        "/websocket": {
+            $get: {
+                input: {};
+                output: {};
+                outputFormat: string;
+                status: hono_utils_http_status.StatusCode;
+            };
+        };
+    } & {
+        "/health": {
+            $get: {
+                input: {};
+                output: "ok";
+                outputFormat: "text";
+                status: hono_utils_http_status.ContentfulStatusCode;
+            };
+        };
+    }, "/", "/health">;
+    constructor(ctx: DurableObjectState, env: TEnv, config: SyncableDurableObjectConfig<TSchema, TTableName>);
+}
+
+export { SyncableDurableObject, type SyncableDurableObjectConfig, type SyncableDurableObjectSyncRow };

package/dist/syncable-durable-object.js

@@ -0,0 +1,4 @@
+export { SyncableDurableObject } from './chunk-ONDKTPGP.js';
+import './chunk-YA4MAETI.js';
+//# sourceMappingURL=syncable-durable-object.js.map
+//# sourceMappingURL=syncable-durable-object.js.map

package/dist/syncable-durable-object.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"syncable-durable-object.js"}

package/package.json

@@ -1,35 +1,37 @@
 {
 	"name": "@firtoz/drizzle-durable-sqlite",
-	"version": "2.0.0",
+	"version": "2.1.0",
 	"description": "TanStack DB collections backed by Drizzle on Cloudflare Durable Object SQLite",
-	"main": "./src/index.ts",
-	"module": "./src/index.ts",
-	"types": "./src/index.ts",
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
 	"type": "module",
 	"exports": {
 		".": {
-			"types": "./src/index.ts",
-			"import": "./src/index.ts",
-			"require": "./src/index.ts"
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
 		},
 		"./durableSqliteCollectionOptions": {
-			"types": "./src/durable-sqlite-collection.ts",
-			"import": "./src/durable-sqlite-collection.ts",
-			"require": "./src/durable-sqlite-collection.ts"
+			"types": "./dist/durable-sqlite-collection.d.ts",
+			"import": "./dist/durable-sqlite-collection.js"
 		},
 		"./*": {
-			"types": "./src/*.ts",
-			"import": "./src/*.ts",
-			"require": "./src/*.ts"
+			"types": "./dist/*.d.ts",
+			"import": "./dist/*.js"
 		}
 	},
 	"files": [
+		"dist/**/*.js",
+		"dist/**/*.js.map",
+		"dist/**/*.d.ts",
 		"src/**/*.ts",
 		"!src/**/*.test.ts",
 		"README.md",
 		"CHANGELOG.md"
 	],
 	"scripts": {
+		"build": "tsup",
+		"prepack": "bun run build",
 		"typecheck": "tsgo --noEmit -p ./tsconfig.json",
 		"lint": "biome check --write src",
 		"lint:ci": "biome ci src",
@@ -68,11 +70,11 @@
 		"valibot": ">=1.3.1"
 	},
 	"dependencies": {
-		"@firtoz/collection-sync": "^5.0.0",
-		"@firtoz/db-helpers": "^2.1.1",
-		"@firtoz/drizzle-utils": "^1.2.1",
-		"@firtoz/maybe-error": "^1.5.2",
-		"@firtoz/websocket-do": "^12.0.0"
+		"@firtoz/collection-sync": "^6.0.0",
+		"@firtoz/db-helpers": "^2.2.0",
+		"@firtoz/drizzle-utils": "^1.3.0",
+		"@firtoz/maybe-error": "^1.6.0",
+		"@firtoz/websocket-do": "^13.0.0"
 	},
 	"devDependencies": {
 		"@cloudflare/workers-types": "^4.20260329.1",

package/src/durable-sqlite-collection.ts

@@ -16,7 +16,6 @@ import type {
 import {
 	createSyncFunction,
 	createInsertSchemaWithIdDefault,
-	createGetKeyFunction,
 	createCollectionConfig,
 	createSqliteTableSyncBackend,
 	type SQLOperation,
@@ -90,8 +89,9 @@ export function durableSqliteCollectionOptions<
 
 	const table = config.drizzle._.fullSchema[tableName] as TTable;
 
-	type TItem = InferSchemaOutput<SelectSchema<TTable>>;
-	const getKey = createGetKeyFunction<TTable>();
+	const getKey = (
+		item: InferSchemaOutput<SelectSchema<TTable>>,
+	): IdOf<TTable> => (item as { id: IdOf<TTable> }).id;
 
 	const backend = createSqliteTableSyncBackend({
 		drizzle: config.drizzle,
@@ -107,7 +107,7 @@ export function durableSqliteCollectionOptions<
 		readyPromise: config.readyPromise ?? Promise.resolve(),
 		syncMode: config.syncMode,
 		debug: config.debug,
-		getSyncPersistKey: (item: TItem) => String(getKey(item)),
+		getSyncPersistKey: (item) => String(getKey(item)),
 	};
 
 	const syncResult = createSyncFunction(baseSyncConfig, backend);