tanstack-db-pglite 1.0.5 → 1.1.0

package/dist/drizzle.d.ts

@@ -1,7 +1,9 @@
 import type { CollectionConfig, DeleteMutationFnParams, InsertMutationFnParams, SyncConfig, UpdateMutationFnParams } from '@tanstack/db';
 import type { IndexColumn, PgTable } from 'drizzle-orm/pg-core';
 import type { PgliteDatabase } from 'drizzle-orm/pglite';
-export declare function drizzleCollectionOptions<Table extends PgTable, SyncParams extends Parameters<SyncConfig<Table['$inferSelect'], string>['sync']>[0] = Parameters<SyncConfig<Table['$inferSelect'], string>['sync']>[0]>({ startSync, ...config }: {
+import type { CreateSelectSchema } from 'drizzle-zod';
+type SyncParams<Table extends PgTable> = Parameters<SyncConfig<Table['$inferSelect'], string>['sync']>[0];
+export declare function drizzleCollectionOptions<Table extends PgTable>({ startSync, ...config }: {
     db: PgliteDatabase<any>;
     table: Table;
     primaryColumn: IndexColumn;
@@ -10,9 +12,8 @@ export declare function drizzleCollectionOptions<Table extends PgTable, SyncPara
     onDelete?: (params: DeleteMutationFnParams<Table['$inferSelect'], string>) => Promise<void>;
     startSync?: boolean;
     prepare?: () => Promise<unknown> | unknown;
-    sync?: (params: Pick<SyncParams, 'write' | 'collection'>) => Promise<void>;
-}): CollectionConfig<Table['$inferSelect'], string> & {
-    utils: {
-        runSync: () => Promise<void>;
-    };
-};
+    sync?: (params: Pick<SyncParams<Table>, 'write' | 'collection'>) => Promise<void>;
+}): CollectionConfig<Table['$inferSelect'], string, ReturnType<CreateSelectSchema<Table['$inferSelect']>>, {
+    runSync: () => Promise<void>;
+}>;
+export {};

package/dist/drizzle.js

@@ -6,32 +6,48 @@ export function drizzleCollectionOptions({ startSync = true, ...config }) {
     // eslint-disable-next-line ts/no-explicit-any
     async function onDrizzleInsert(data, tx) {
         // @ts-expect-error drizzle types
-        await (tx || config.db).insert(config.table).values(data);
+        await (tx || config.db).insert(config.table).values(data).catch((e) => {
+            if (e instanceof Error && e.cause) {
+                throw e.cause;
+            }
+            throw e;
+        });
     }
     // eslint-disable-next-line ts/no-explicit-any
     async function onDrizzleUpdate(id, changes, tx) {
-        await (tx || config.db).update(config.table).set(changes).where(eq(config.primaryColumn, id));
+        await (tx || config.db).update(config.table).set(changes).where(eq(config.primaryColumn, id)).catch((e) => {
+            if (e instanceof Error && e.cause) {
+                throw e.cause;
+            }
+            throw e;
+        });
     }
     // eslint-disable-next-line ts/no-explicit-any
     async function onDrizzleDelete(ids, tx) {
-        await (tx || config.db).delete(config.table).where(inArray(config.primaryColumn, ids));
+        await (tx || config.db).delete(config.table).where(inArray(config.primaryColumn, ids)).catch((e) => {
+            if (e instanceof Error && e.cause) {
+                throw e.cause;
+            }
+            throw e;
+        });
     }
     const getSyncParams = async () => {
         const params = await syncParams;
         return {
-            write: async (p) => {
+            write: async (message) => {
                 params.begin();
                 try {
-                    if (p.type === 'insert') {
-                        await onDrizzleInsert([p.value]);
+                    if (message.type === 'insert') {
+                        await onDrizzleInsert([message.value]);
                     }
-                    else if (p.type === 'update') {
-                        await onDrizzleUpdate(params.collection.getKeyFromItem(p.value), p.value);
+                    else if (message.type === 'update') {
+                        await onDrizzleUpdate(params.collection.getKeyFromItem(message.value), message.value);
                     }
-                    else if (p.type === 'delete') {
-                        await onDrizzleDelete([params.collection.getKeyFromItem(p.value)]);
+                    else if (message.type === 'delete') {
+                        const key = 'key' in message ? message.key : params.collection.getKeyFromItem(message.value);
+                        await onDrizzleDelete([key]);
                     }
-                    params.write(p);
+                    params.write(message);
                 }
                 finally {
                     params.commit();
@@ -45,7 +61,12 @@ export function drizzleCollectionOptions({ startSync = true, ...config }) {
         const { begin, write, commit } = await syncParams;
         begin();
         mutations.forEach((m) => {
-            write({ type: m.type, value: m.modified });
+            if (m.type === 'delete') {
+                write({ type: 'delete', key: m.key });
+            }
+            else {
+                write({ type: m.type, value: m.modified });
+            }
         });
         commit();
     }

package/dist/index.d.ts

@@ -1 +1,2 @@
 export * from './drizzle';
+export * from './sql';

package/dist/index.js

@@ -1 +1,2 @@
 export * from './drizzle';
+export * from './sql';

package/dist/sql.d.ts

@@ -0,0 +1,23 @@
+import type { PGlite } from '@electric-sql/pglite';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { CollectionConfig, DeleteMutationFnParams, InsertMutationFnParams, SyncConfig, UpdateMutationFnParams } from '@tanstack/db';
+type Output<T extends StandardSchemaV1> = StandardSchemaV1.InferOutput<T>;
+type SyncParams<ItemType extends Record<string, unknown>> = Parameters<SyncConfig<ItemType, string>['sync']>[0];
+export declare function sqlCollectionOptions<Schema extends StandardSchemaV1<Record<string, unknown>>>({ startSync, ...config }: {
+    db: PGlite;
+    tableName: string;
+    primaryKeyColumn: Extract<keyof Output<Schema>, string>;
+    schema: Schema;
+    getKey?: (row: Output<Schema>) => string;
+    onInsert?: (params: InsertMutationFnParams<Output<Schema>, string>) => Promise<void>;
+    onUpdate?: (params: UpdateMutationFnParams<Output<Schema>, string>) => Promise<void>;
+    onDelete?: (params: DeleteMutationFnParams<Output<Schema>, string>) => Promise<void>;
+    startSync?: boolean;
+    prepare?: () => Promise<unknown> | unknown;
+    sync?: (params: Pick<SyncParams<Output<Schema>>, 'write' | 'collection'>) => Promise<void>;
+}): CollectionConfig<Output<Schema>, string, Schema, {
+    runSync: () => Promise<void>;
+}> & {
+    schema: Schema;
+};
+export {};

package/dist/sql.js

@@ -0,0 +1,141 @@
+function quoteId(name) {
+    // eslint-disable-next-line e18e/prefer-static-regex
+    return `"${String(name).replace(/"/g, '""')}"`;
+}
+export function sqlCollectionOptions({ startSync = true, ...config }) {
+    const table = quoteId(config.tableName);
+    const primaryKey = quoteId(config.primaryKeyColumn);
+    const getKey = config.getKey ?? ((row) => String(row[config.primaryKeyColumn]));
+    const { promise: syncParams, resolve: resolveSyncParams } = Promise.withResolvers();
+    async function runSelect(client) {
+        const result = await client.query(`SELECT * FROM ${table}`);
+        return (result.rows ?? []);
+    }
+    async function runInsert(client, rows) {
+        for (const row of rows) {
+            const cols = Object.keys(row).filter(k => row[k] !== undefined);
+            if (cols.length === 0)
+                continue;
+            const columns = cols.map(quoteId).join(', ');
+            const placeholders = cols.map((_, i) => `$${i + 1}`).join(', ');
+            const values = cols.map(c => row[c]);
+            await client.query(`INSERT INTO ${table} (${columns}) VALUES (${placeholders})`, values);
+        }
+    }
+    async function runUpdate(client, id, changes) {
+        const entries = Object.entries(changes).filter(([, v]) => v !== undefined);
+        if (entries.length === 0)
+            return;
+        const setClause = entries.map(([k], i) => `${quoteId(k)} = $${i + 1}`).join(', ');
+        const params = [...entries.map(([, v]) => v), id];
+        await client.query(`UPDATE ${table} SET ${setClause} WHERE ${primaryKey} = $${params.length}`, params);
+    }
+    async function runDelete(client, ids) {
+        if (ids.length === 0)
+            return;
+        await client.query(`DELETE FROM ${table} WHERE ${primaryKey} = ANY($1)`, [ids]);
+    }
+    const getSyncParams = async () => {
+        const params = await syncParams;
+        return {
+            write: async (p) => {
+                params.begin();
+                try {
+                    if (p.type === 'insert') {
+                        await runInsert(config.db, [p.value]);
+                    }
+                    else if (p.type === 'update') {
+                        await runUpdate(config.db, params.collection.getKeyFromItem(p.value), p.value);
+                    }
+                    else if (p.type === 'delete') {
+                        const key = 'key' in p ? p.key : params.collection.getKeyFromItem(p.value);
+                        await runDelete(config.db, [key]);
+                    }
+                    params.write(p);
+                }
+                finally {
+                    params.commit();
+                }
+            },
+            collection: params.collection,
+        };
+    };
+    async function runMutations(mutations) {
+        const { begin, write, commit } = await syncParams;
+        begin();
+        mutations.forEach((m) => {
+            if (m.type === 'delete') {
+                write({ type: 'delete', key: m.key });
+            }
+            else {
+                write({ type: m.type, value: m.modified });
+            }
+        });
+        commit();
+    }
+    return {
+        startSync,
+        sync: {
+            sync: (params) => {
+                resolveSyncParams(params);
+                (async () => {
+                    try {
+                        await config.prepare?.();
+                        params.begin();
+                        const rows = await runSelect(config.db);
+                        rows.forEach((row) => {
+                            params.write({ type: 'insert', value: row });
+                        });
+                        params.commit();
+                        if (config.sync && startSync) {
+                            await config.sync(await getSyncParams());
+                        }
+                    }
+                    finally {
+                        params.markReady();
+                    }
+                })();
+            },
+        },
+        gcTime: 0,
+        schema: config.schema,
+        getKey,
+        onInsert: async (params) => {
+            await config.db.transaction(async (tx) => {
+                await runInsert(tx, params.transaction.mutations.map(m => m.modified));
+                if (config.onInsert) {
+                    await config.onInsert(params);
+                }
+            });
+            await runMutations(params.transaction.mutations);
+        },
+        onUpdate: async (params) => {
+            await config.db.transaction(async (tx) => {
+                await Promise.all(params.transaction.mutations.map(m => runUpdate(tx, m.key, m.changes)));
+                if (config.onUpdate) {
+                    await config.onUpdate(params);
+                }
+            });
+            await runMutations(params.transaction.mutations);
+        },
+        onDelete: async (params) => {
+            await config.db.transaction(async (tx) => {
+                await runDelete(tx, params.transaction.mutations.map(m => m.key));
+                if (config.onDelete) {
+                    await config.onDelete(params);
+                }
+            });
+            await runMutations(params.transaction.mutations);
+        },
+        utils: {
+            runSync: async () => {
+                if (!config.sync) {
+                    throw new Error('Sync is not defined');
+                }
+                const params = await getSyncParams();
+                await params.collection.stateWhenReady();
+                await config.sync(params);
+            },
+        },
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tanstack-db-pglite",
-  "version": "1.0.5",
-  "packageManager": "pnpm@10.22.0",
+  "version": "1.1.0",
+  "packageManager": "pnpm@10.32.1",
   "description": "",
   "author": "Valerii Strilets",
   "license": "MIT",
@@ -25,19 +25,28 @@
     "prepublishOnly": "pnpm build",
     "build": "tsc",
     "lint": "eslint .",
-    "lint:fix": "eslint . --fix"
+    "lint:fix": "eslint . --fix",
+    "update": "taze -r -I major"
   },
   "peerDependencies": {
+    "@electric-sql/pglite": ">=0.3.0",
     "@tanstack/db": ">=0.5.0",
-    "drizzle-orm": ">=0.44.0"
+    "drizzle-orm": ">=0.45.0"
+  },
+  "peerDependenciesMeta": {
+    "drizzle-orm": {
+      "optional": true
+    }
   },
   "dependencies": {
     "drizzle-zod": "^0.8.3"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^6.2.0",
-    "eslint": "^9.39.1",
+    "@antfu/eslint-config": "^7.7.2",
+    "@standard-schema/spec": "^1.1.0",
+    "eslint": "^10.0.3",
     "jiti": "^2.6.1",
+    "taze": "^19.10.0",
     "typescript": "^5.9.3"
   }
 }

package/dist/drizzle-collection-options.d.ts

@@ -1,20 +0,0 @@
-import type { CollectionConfig, DeleteMutationFnParams, InsertMutationFnParams, SyncConfig, UpdateMutationFnParams } from '@tanstack/db';
-import type { IndexColumn, PgTable } from 'drizzle-orm/pg-core';
-import type { PgliteDatabase } from 'drizzle-orm/pglite';
-export declare function drizzleCollectionOptions<Table extends PgTable>({ startSync, ...config }: {
-    db: PgliteDatabase<any>;
-    table: Table;
-    primaryColumn: IndexColumn;
-    onInsert?: (params: InsertMutationFnParams<Table['$inferSelect'], string>) => Promise<void>;
-    onUpdate?: (params: UpdateMutationFnParams<Table['$inferSelect'], string>) => Promise<void>;
-    onDelete?: (params: DeleteMutationFnParams<Table['$inferSelect'], string>) => Promise<void>;
-    startSync?: boolean;
-    sync: {
-        prepare?: () => Promise<any> | any;
-        sync: (params: Pick<Parameters<SyncConfig<Table['$inferSelect'], string>['sync']>[0], 'write' | 'collection'>) => Promise<void>;
-    };
-}): CollectionConfig<Table['$inferSelect'], string> & {
-    utils: {
-        runSync: () => Promise<void>;
-    };
-};

package/dist/drizzle-collection-options.js

@@ -1,106 +0,0 @@
-import { eq, inArray } from 'drizzle-orm';
-import { createSelectSchema } from 'drizzle-zod';
-export function drizzleCollectionOptions({ startSync = true, ...config }) {
-    // Sync params can be null while running PGLite migrations
-    const { promise: syncParams, resolve: resolveSyncParams } = Promise.withResolvers();
-    async function runMutations(mutations) {
-        const { begin, write, commit } = await syncParams;
-        begin();
-        mutations.forEach((m) => {
-            write({ type: m.type, value: m.modified });
-        });
-        commit();
-    }
-    async function onDrizzleInsert(data) {
-        // @ts-expect-error drizzle types
-        await config.db.insert(config.table).values(data);
-    }
-    async function onDrizzleUpdate(id, changes) {
-        await config.db
-            .update(config.table)
-            .set(changes)
-            .where(eq(config.primaryColumn, id));
-    }
-    async function onDrizzleDelete(ids) {
-        await config.db
-            .delete(config.table)
-            .where(inArray(config.primaryColumn, ids));
-    }
-    const getSyncParams = async () => {
-        const params = await syncParams;
-        return {
-            write: async (p) => {
-                params.begin();
-                try {
-                    if (p.type === 'insert') {
-                        await onDrizzleInsert([p.value]);
-                    }
-                    else if (p.type === 'update') {
-                        await onDrizzleUpdate(params.collection.getKeyFromItem(p.value), p.value);
-                    }
-                    else if (p.type === 'delete') {
-                        await onDrizzleDelete([params.collection.getKeyFromItem(p.value)]);
-                    }
-                    params.write(p);
-                }
-                finally {
-                    params.commit();
-                }
-            },
-            collection: params.collection,
-        };
-    };
-    return {
-        startSync: true,
-        sync: {
-            sync: async (params) => {
-                try {
-                    resolveSyncParams(params);
-                    await config.sync.prepare?.();
-                    params.begin();
-                    // @ts-expect-error drizzle types
-                    const dbs = await config.db.select().from(config.table);
-                    dbs.forEach((db) => {
-                        params.write({ type: 'insert', value: db });
-                    });
-                    params.commit();
-                    if (config.sync && startSync) {
-                        await config.sync.sync(await getSyncParams());
-                    }
-                }
-                finally {
-                    params.markReady();
-                }
-            },
-        },
-        gcTime: 0,
-        schema: createSelectSchema(config.table),
-        getKey: t => t[config.primaryColumn.name],
-        onDelete: async (params) => {
-            await onDrizzleDelete(params.transaction.mutations.map(m => m.key));
-            const result = await config.onDelete?.(params);
-            await runMutations(params.transaction.mutations);
-            return result;
-        },
-        onInsert: async (params) => {
-            await onDrizzleInsert(params.transaction.mutations.map(m => m.modified));
-            const result = await config.onInsert?.(params);
-            await runMutations(params.transaction.mutations);
-            return result;
-        },
-        onUpdate: async (params) => {
-            await Promise.all(params.transaction.mutations.map(m => onDrizzleUpdate(m.key, m.changes)));
-            const result = await config.onUpdate?.(params);
-            await runMutations(params.transaction.mutations);
-            return result;
-        },
-        utils: {
-            runSync: async () => {
-                const params = await getSyncParams();
-                // To wait the first sync
-                await params.collection.stateWhenReady();
-                await config.sync.sync(params);
-            },
-        },
-    };
-}