chore: use the entire kysely dialect in client options (#130)

ymc9 · web-flow · commit 0f29b39549e7 · 2025-07-31T15:18:46.000+08:00
diff --git a/README.md b/README.md
@@ -145,9 +145,10 @@ Now you can use the compiled TypeScript schema to instantiate a database client.
 import { ZenStackClient } from '@zenstackhq/runtime';
 import { schema } from './zenstack/schema';
 import SQLite from 'better-sqlite3';
+import { SqliteDialect } from 'kysely';
 
 const client = new ZenStackClient(schema, {
-    dialectConfig: { database: new SQLite('./dev.db') },
+    dialect: new SqliteDialect({ database: new SQLite('./dev.db') }),
 });
 ```
 
@@ -156,13 +157,14 @@ const client = new ZenStackClient(schema, {
 ```ts
 import { ZenStackClient } from '@zenstackhq/runtime';
 import { schema } from './zenstack/schema';
+import { PostgresDialect } from 'kysely';
 import { Pool } from 'pg';
 import { parseIntoClientConfig } from 'pg-connection-string';
 
 const client = new ZenStackClient(schema, {
-    dialectConfig: {
+    dialect: new PostgresDialect({
         pool: new Pool(parseIntoClientConfig(process.env.DATABASE_URL)),
-    },
+    }),
 });
 ```
 
diff --git a/packages/cli/src/actions/generate.ts b/packages/cli/src/actions/generate.ts
@@ -50,7 +50,7 @@ import { ZenStackClient } from '@zenstackhq/runtime';
 import { schema } from '${outputPath}/schema';
 
 const client = new ZenStackClient(schema, {
-    dialectConfig: { ... }
+    dialect: { ... }
 });
 \`\`\`
 `);
diff --git a/packages/cli/src/actions/templates.ts b/packages/cli/src/actions/templates.ts
@@ -27,14 +27,15 @@ model Post {
 `;
 
 export const STARTER_MAIN_TS = `import { ZenStackClient } from '@zenstackhq/runtime';
-import { schema } from './zenstack/schema';
 import SQLite from 'better-sqlite3';
+import { SqliteDialect } from 'kysely';
+import { schema } from './zenstack/schema';
 
 async function main() {
     const client = new ZenStackClient(schema, {
-        dialectConfig: {
+        dialect: new SqliteDialect({
             database: new SQLite('./zenstack/dev.db'),
-        },
+        }),
     });
     const user = await client.user.create({
         data: {
diff --git a/packages/runtime/package.json b/packages/runtime/package.json
@@ -69,14 +69,14 @@
         "@paralleldrive/cuid2": "^2.2.2",
         "decimal.js": "^10.4.3",
         "json-stable-stringify": "^1.3.0",
-        "kysely": "catalog:",
         "nanoid": "^5.0.9",
         "ts-pattern": "catalog:",
         "ulid": "^3.0.0",
         "uuid": "^11.0.5"
     },
     "peerDependencies": {
         "better-sqlite3": "^11.8.1",
+        "kysely": "catalog:",
         "pg": "^8.13.1",
         "zod": "catalog:"
     },
diff --git a/packages/runtime/src/client/client-impl.ts b/packages/runtime/src/client/client-impl.ts
@@ -1,18 +1,14 @@
 import { invariant, lowerCaseFirst } from '@zenstackhq/common-helpers';
-import type { QueryExecutor, SqliteDialectConfig } from 'kysely';
+import type { QueryExecutor } from 'kysely';
 import {
     CompiledQuery,
     DefaultConnectionProvider,
     DefaultQueryExecutor,
     Kysely,
     Log,
-    PostgresDialect,
     sql,
-    SqliteDialect,
     type KyselyProps,
-    type PostgresDialectConfig,
 } from 'kysely';
-import { match } from 'ts-pattern';
 import type { GetModels, ProcedureDef, SchemaDef } from '../schema';
 import type { AuthType } from '../schema/auth';
 import type { UnwrapTuplePromises } from '../utils/type-utils';
@@ -88,18 +84,17 @@ export class ClientImpl<Schema extends SchemaDef> {
             this.kyselyRaw = baseClient.kyselyRaw;
             this.auth = baseClient.auth;
         } else {
-            const dialect = this.getKyselyDialect();
-            const driver = new ZenStackDriver(dialect.createDriver(), new Log(this.$options.log ?? []));
-            const compiler = dialect.createQueryCompiler();
-            const adapter = dialect.createAdapter();
+            const driver = new ZenStackDriver(options.dialect.createDriver(), new Log(this.$options.log ?? []));
+            const compiler = options.dialect.createQueryCompiler();
+            const adapter = options.dialect.createAdapter();
             const connectionProvider = new DefaultConnectionProvider(driver);
 
             this.kyselyProps = {
                 config: {
-                    dialect,
+                    dialect: options.dialect,
                     log: this.$options.log,
                 },
-                dialect,
+                dialect: options.dialect,
                 driver,
                 executor: executor ?? new ZenStackQueryExecutor(this, driver, compiler, adapter, connectionProvider),
             };
@@ -135,21 +130,6 @@ export class ClientImpl<Schema extends SchemaDef> {
         return new ClientImpl(this.schema, this.$options, this, executor);
     }
 
-    private getKyselyDialect() {
-        return match(this.schema.provider.type)
-            .with('sqlite', () => this.makeSqliteKyselyDialect())
-            .with('postgresql', () => this.makePostgresKyselyDialect())
-            .exhaustive();
-    }
-
-    private makePostgresKyselyDialect(): PostgresDialect {
-        return new PostgresDialect(this.options.dialectConfig as PostgresDialectConfig);
-    }
-
-    private makeSqliteKyselyDialect(): SqliteDialect {
-        return new SqliteDialect(this.options.dialectConfig as SqliteDialectConfig);
-    }
-
     // overload for interactive transaction
     $transaction<T>(
         callback: (tx: ClientContract<Schema>) => Promise<T>,
diff --git a/packages/runtime/src/client/options.ts b/packages/runtime/src/client/options.ts
@@ -1,17 +1,11 @@
-import type { Expression, ExpressionBuilder, KyselyConfig, PostgresDialectConfig, SqliteDialectConfig } from 'kysely';
-import type { DataSourceProvider, GetModel, GetModels, ProcedureDef, SchemaDef } from '../schema';
-import type { Optional, PrependParameter } from '../utils/type-utils';
+import type { Dialect, Expression, ExpressionBuilder, KyselyConfig } from 'kysely';
+import type { GetModel, GetModels, ProcedureDef, SchemaDef } from '../schema';
+import type { PrependParameter } from '../utils/type-utils';
 import type { ClientContract, CRUD, ProcedureFunc } from './contract';
 import type { BaseCrudDialect } from './crud/dialects/base';
 import type { RuntimePlugin } from './plugin';
 import type { ToKyselySchema } from './query-builder';
 
-type DialectConfig<Provider extends DataSourceProvider> = Provider['type'] extends 'sqlite'
-    ? Optional<SqliteDialectConfig, 'database'>
-    : Provider['type'] extends 'postgresql'
-      ? Optional<PostgresDialectConfig, 'pool'>
-      : never;
-
 export type ZModelFunctionContext<Schema extends SchemaDef> = {
     dialect: BaseCrudDialect<Schema>;
     model: GetModels<Schema>;
@@ -29,9 +23,9 @@ export type ZModelFunction<Schema extends SchemaDef> = (
  */
 export type ClientOptions<Schema extends SchemaDef> = {
     /**
-     * Database dialect configuration.
+     * Kysely dialect.
      */
-    dialectConfig: DialectConfig<Schema['provider']>;
+    dialect: Dialect;
 
     /**
      * Custom function definitions.
diff --git a/packages/runtime/test/client-api/computed-fields.test.ts b/packages/runtime/test/client-api/computed-fields.test.ts
@@ -55,7 +55,7 @@ import { schema } from './schema';
 
 async function main() {
     const client = new ZenStackClient(schema, {
-        dialectConfig: {} as any,
+        dialect: {} as any,
         computedFields: {
             User: {
                 upperName: (eb) => eb.fn('upper', ['name']),
@@ -122,7 +122,7 @@ import { schema } from './schema';
 
 async function main() {
     const client = new ZenStackClient(schema, {
-        dialectConfig: {} as any,
+        dialect: {} as any,
         computedFields: {
             User: {
                 upperName: (eb) => eb.lit(null),
diff --git a/packages/runtime/test/client-api/default-values.test.ts b/packages/runtime/test/client-api/default-values.test.ts
@@ -1,5 +1,6 @@
 import { isCuid } from '@paralleldrive/cuid2';
 import SQLite from 'better-sqlite3';
+import { SqliteDialect } from 'kysely';
 import { isValid as isValidUlid } from 'ulid';
 import { validate as isValidUuid } from 'uuid';
 import { describe, expect, it } from 'vitest';
@@ -68,7 +69,7 @@ const schema = {
 describe('default values tests', () => {
     it('supports generators', async () => {
         const client = new ZenStackClient(schema, {
-            dialectConfig: { database: new SQLite(':memory:') },
+            dialect: new SqliteDialect({ database: new SQLite(':memory:') }),
         });
         await client.$pushSchema();
 
diff --git a/packages/runtime/test/client-api/name-mapping.test.ts b/packages/runtime/test/client-api/name-mapping.test.ts
@@ -1,4 +1,5 @@
 import SQLite from 'better-sqlite3';
+import { SqliteDialect } from 'kysely';
 import { describe, expect, it } from 'vitest';
 import { ZenStackClient } from '../../src';
 import { type SchemaDef, ExpressionUtils } from '../../src/schema';
@@ -59,7 +60,7 @@ describe('Name mapping tests', () => {
 
     it('works with model and implicit field mapping', async () => {
         const client = new ZenStackClient(schema, {
-            dialectConfig: { database: new SQLite(':memory:') },
+            dialect: new SqliteDialect({ database: new SQLite(':memory:') }),
         });
         await client.$pushSchema();
         const r1 = await client.foo.create({
@@ -91,7 +92,7 @@ describe('Name mapping tests', () => {
 
     it('works with explicit field mapping', async () => {
         const client = new ZenStackClient(schema, {
-            dialectConfig: { database: new SQLite(':memory:') },
+            dialect: new SqliteDialect({ database: new SQLite(':memory:') }),
         });
         await client.$pushSchema();
         const r1 = await client.foo.create({
diff --git a/packages/runtime/test/plugin/kysely-on-query.test.ts b/packages/runtime/test/plugin/kysely-on-query.test.ts
@@ -1,5 +1,5 @@
 import SQLite from 'better-sqlite3';
-import { InsertQueryNode, Kysely, PrimitiveValueListNode, ValuesNode, type QueryResult } from 'kysely';
+import { InsertQueryNode, Kysely, PrimitiveValueListNode, SqliteDialect, ValuesNode, type QueryResult } from 'kysely';
 import { beforeEach, describe, expect, it } from 'vitest';
 import { ZenStackClient, type ClientContract } from '../../src/client';
 import { schema } from '../schemas/basic';
@@ -9,7 +9,7 @@ describe('Kysely onQuery tests', () => {
 
     beforeEach(async () => {
         _client = new ZenStackClient(schema, {
-            dialectConfig: { database: new SQLite(':memory:') },
+            dialect: new SqliteDialect({ database: new SQLite(':memory:') }),
         });
         await _client.$pushSchema();
     });
diff --git a/packages/runtime/test/plugin/mutation-hooks.test.ts b/packages/runtime/test/plugin/mutation-hooks.test.ts
@@ -1,5 +1,5 @@
 import SQLite from 'better-sqlite3';
-import { DeleteQueryNode, InsertQueryNode, UpdateQueryNode } from 'kysely';
+import { DeleteQueryNode, InsertQueryNode, SqliteDialect, UpdateQueryNode } from 'kysely';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { ZenStackClient, type ClientContract } from '../../src';
 import { schema } from '../schemas/basic';
@@ -9,9 +9,7 @@ describe('Entity  lifecycle tests', () => {
 
     beforeEach(async () => {
         _client = new ZenStackClient(schema, {
-            dialectConfig: {
-                database: new SQLite(':memory:'),
-            },
+            dialect: new SqliteDialect({ database: new SQLite(':memory:') }),
         });
         await _client.$pushSchema();
     });
diff --git a/packages/runtime/test/plugin/query-lifecycle.test.ts b/packages/runtime/test/plugin/query-lifecycle.test.ts
@@ -1,4 +1,5 @@
 import SQLite from 'better-sqlite3';
+import { SqliteDialect } from 'kysely';
 import { beforeEach, describe, expect, it } from 'vitest';
 import { definePlugin, ZenStackClient, type ClientContract } from '../../src/client';
 import { schema } from '../schemas/basic';
@@ -8,9 +9,7 @@ describe('Query interception tests', () => {
 
     beforeEach(async () => {
         _client = new ZenStackClient(schema, {
-            dialectConfig: {
-                database: new SQLite(':memory:'),
-            },
+            dialect: new SqliteDialect({ database: new SQLite(':memory:') }),
         });
         await _client.$pushSchema();
     });
diff --git a/packages/runtime/test/query-builder/query-builder.test.ts b/packages/runtime/test/query-builder/query-builder.test.ts
@@ -1,5 +1,6 @@
 import { createId } from '@paralleldrive/cuid2';
 import SQLite from 'better-sqlite3';
+import { SqliteDialect } from 'kysely';
 import { describe, expect, it } from 'vitest';
 import { ZenStackClient } from '../../src';
 import { getSchema } from '../schemas/basic';
@@ -9,9 +10,7 @@ describe('Client API tests', () => {
 
     it('works with queries', async () => {
         const client = new ZenStackClient(schema, {
-            dialectConfig: {
-                database: new SQLite(':memory:'),
-            },
+            dialect: new SqliteDialect({ database: new SQLite(':memory:') }),
         });
         await client.$pushSchema();
 
diff --git a/packages/runtime/test/schemas/delegate/typecheck.ts b/packages/runtime/test/schemas/delegate/typecheck.ts
@@ -1,11 +1,10 @@
 import SQLite from 'better-sqlite3';
+import { SqliteDialect } from 'kysely';
 import { ZenStackClient } from '../../../dist';
 import { schema } from './schema';
 
 const client = new ZenStackClient(schema, {
-    dialectConfig: {
-        database: new SQLite('./zenstack/test.db'),
-    },
+    dialect: new SqliteDialect({ database: new SQLite('./zenstack/test.db') }),
 });
 
 async function find() {
diff --git a/packages/runtime/test/schemas/typing/typecheck.ts b/packages/runtime/test/schemas/typing/typecheck.ts
@@ -1,12 +1,11 @@
 import SQLite from 'better-sqlite3';
+import { SqliteDialect } from 'kysely';
 import { ZenStackClient } from '../../../dist';
 import { Role, type Identity, type IdentityProvider } from './models';
 import { schema } from './schema';
 
 const client = new ZenStackClient(schema, {
-    dialectConfig: {
-        database: new SQLite('./zenstack/test.db'),
-    },
+    dialect: new SqliteDialect({ database: new SQLite('./zenstack/test.db') }),
     computedFields: {
         User: {
             postCount: (eb) =>
diff --git a/packages/runtime/test/utils.ts b/packages/runtime/test/utils.ts
@@ -3,6 +3,7 @@ import { loadDocument } from '@zenstackhq/language';
 import { PrismaSchemaGenerator } from '@zenstackhq/sdk';
 import { createTestProject, generateTsSchema } from '@zenstackhq/testtools';
 import SQLite from 'better-sqlite3';
+import { PostgresDialect, SqliteDialect } from 'kysely';
 import { execSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -20,7 +21,7 @@ export async function makeSqliteClient<Schema extends SqliteSchema>(
 ): Promise<ClientContract<Schema>> {
     const client = new ZenStackClient(schema, {
         ...extraOptions,
-        dialectConfig: { database: new SQLite(':memory:') },
+        dialect: new SqliteDialect({ database: new SQLite(':memory:') }),
     } as unknown as ClientOptions<Schema>);
     await client.$pushSchema();
     return client;
@@ -46,18 +47,18 @@ export async function makePostgresClient<Schema extends PostgresSchema>(
 
     const client = new ZenStackClient(schema, {
         ...extraOptions,
-        dialectConfig: {
+        dialect: new PostgresDialect({
             pool: new Pool({
                 ...TEST_PG_CONFIG,
                 database: dbName,
             }),
-        },
+        }),
     } as unknown as ClientOptions<Schema>);
     await client.$pushSchema();
     return client;
 }
 
-export type CreateTestClientOptions<Schema extends SchemaDef> = Omit<ClientOptions<Schema>, 'dialectConfig'> & {
+export type CreateTestClientOptions<Schema extends SchemaDef> = Omit<ClientOptions<Schema>, 'dialect'> & {
     provider?: 'sqlite' | 'postgresql';
     dbName?: string;
     usePrismaPush?: boolean;
@@ -166,16 +167,16 @@ export async function createTestClient<Schema extends SchemaDef>(
     }
 
     if (provider === 'postgresql') {
-        _options.dialectConfig = {
+        _options.dialect = new PostgresDialect({
             pool: new Pool({
                 ...TEST_PG_CONFIG,
                 database: dbName,
             }),
-        } as unknown as ClientOptions<Schema>['dialectConfig'];
+        });
     } else {
-        _options.dialectConfig = {
+        _options.dialect = new SqliteDialect({
             database: new SQLite(path.join(workDir!, dbName)),
-        } as unknown as ClientOptions<Schema>['dialectConfig'];
+        });
     }
 
     let client = new ZenStackClient(_schema, _options);
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
diff --git a/samples/blog/README.md b/samples/blog/README.md
diff --git a/samples/blog/main.ts b/samples/blog/main.ts
diff --git a/samples/blog/package.json b/samples/blog/package.json
