kysely 0.11.4 → 0.13.0

package/README.md

@@ -72,7 +72,7 @@ interface Person {
   first_name: string
   // If the column is nullable in the db, make its type nullable.
   // Don't use optional properties.
-  last_name: string | null
+  last_name: string | null
   gender: 'male' | 'female' | 'other'
 }
 
@@ -252,32 +252,56 @@ await db.migration.migrateToLatest(pathToMigrationsFolder)
 ```
 
 to run all migrations that have not yet been run. The migrations are executed in alphabetical
-order by their file name.
+order by their name. See the [migration module](https://koskimas.github.io/kysely/classes/MigrationModule.html) 
+documentation for more info.
 
 Kysely doesn't have a CLI for running migrations and probably never will. This is because Kysely's
 migrations are also written in typescript. To run the migrations, you need to first build the
 typescript code into javascript. The CLI would cause confusion over which migrations are being
-run, the typescript ones or the javascript ones. If we added support for both, it would mean the
-CLI would depend on a typescript compiler, which most production environments don't (and shouldn't)
+run, the typescript ones or the javascript ones. If we added support for both, the CLI would 
+need to depend on a typescript compiler, which most production environments don't (and shouldn't)
 have. You will probably want to add a simple migration script to your projects like this:
 
 ```ts
 import path from 'path'
+
+// This example assumes you have a file named `database.ts` that
+// creates and exports a `Kysely` instance `db`. You can just
+// as well create a new `Kysely` instance in the function below
+// or do something completely different to obtain an instance
+// of `Kysely`.
 import { db } from './database'
 
-db.migration
-  .migrateToLatest(path.join(__dirname, 'migrations'))
-  .then(() => db.destroy())
+async function migrateToLatest() {
+  const { error, results } = await db.migration.migrateToLatest(
+    path.join(__dirname, 'migrations')
+  )
+
+  // Destroy the `Kysely` instance to make the script exit faster.
+  await db.destroy()
+
+  results?.forEach((it) => {
+    if (it.status === 'Success') {
+      console.log(`migration "${it.migrationName}" was executed successfully`)
+    } else if (it.status === 'Error') {
+      console.error(`failed to execute migration "${it.migrationName}"`)
+    }
+  })
+
+  if (error) {
+    console.error('failed to migrate')
+    console.error(error)
+    process.exit(1)
+  }
+}
+
+migrateToLatest()
 ```
 
 The migration methods use a lock on the database level, and parallel calls are executed serially.
 This means that you can safely call `migrateToLatest` and other migration methods from multiple
 server instances simultaneously and the migrations are guaranteed to only be executed once.
 
-NOTE: Only `db.migration.migrateToLatest` method is implemented at the moment. There is no way
-to run the down migrations, or to go forward to a specific migration. These methods will be
-added soon.
-
 # Why not just contribute to knex
 
 Kysely is very similar to knex, but it also attempts to fix things that I personally find not-so-good

package/dist/cjs/dialect/dialect-adapter-base.d.ts

@@ -7,8 +7,44 @@ import { DialectAdapter } from './dialect-adapter.js';
  * they are added and there will be less breaking changes.
  */
 export declare abstract class DialectAdapterBase implements DialectAdapter {
+    /**
+     * Whether or not this dialect supports transactional DDL.
+     *
+     * If this is true, migrations are executed inside a transaction.
+     */
     get supportsTransactionalDdl(): boolean;
+    /**
+     * Whether or not this dialect supports the `returning` in inserts
+     * updates and deletes.
+     */
     get supportsReturning(): boolean;
+    /**
+     * This method is used to acquire a lock for the migrations so that
+     * it's not possible for two migration processes to run in parallel.
+     *
+     * Most dialects have explicit locks that can be used, like advisory locks
+     * in PostgreSQL and the get_lock function in MySQL.
+     *
+     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
+     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
+     * has two columns `id` and `is_locked` and there's only one row in the
+     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
+     * Kysely takes care of creating the lock table and inserting the one single
+     * row to it before this method is executed.
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations will be executed. Otherwise
+     * `db` is a single connection (session) that will be used to execute the
+     * migrations.
+     */
     abstract acquireMigrationLock(db: Kysely<any>): Promise<void>;
+    /**
+     * Releases the migration lock. See {@link acquireMigrationLock}.
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations were executed. Otherwise `db`
+     * is a single connection (session) that was used to execute the migrations
+     * and the `acquireMigrationLock` call.
+     */
     abstract releaseMigrationLock(db: Kysely<any>): Promise<void>;
 }

package/dist/cjs/dialect/mysql/mysql-adapter.d.ts

@@ -1,8 +1,44 @@
 import { Kysely } from '../../kysely.js';
-import { DialectAdapter } from '../dialect-adapter.js';
-export declare class MysqlAdapter implements DialectAdapter {
+import { DialectAdapterBase } from '../dialect-adapter-base.js';
+export declare class MysqlAdapter extends DialectAdapterBase {
+    /**
+     * Whether or not this dialect supports transactional DDL.
+     *
+     * If this is true, migrations are executed inside a transaction.
+     */
     get supportsTransactionalDdl(): boolean;
+    /**
+     * Whether or not this dialect supports the `returning` in inserts
+     * updates and deletes.
+     */
     get supportsReturning(): boolean;
+    /**
+     * This method is used to acquire a lock for the migrations so that
+     * it's not possible for two migration processes to run in parallel.
+     *
+     * Most dialects have explicit locks that can be used, like advisory locks
+     * in PostgreSQL and the get_lock function in MySQL.
+     *
+     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
+     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
+     * has two columns `id` and `is_locked` and there's only one row in the
+     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
+     * Kysely takes care of creating the lock table and inserting the one single
+     * row to it before this method is executed.
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations will be executed. Otherwise
+     * `db` is a single connection (session) that will be used to execute the
+     * migrations.
+     */
     acquireMigrationLock(db: Kysely<any>): Promise<void>;
+    /**
+     * Releases the migration lock. See {@link acquireMigrationLock}.
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations were executed. Otherwise `db`
+     * is a single connection (session) that was used to execute the migrations
+     * and the `acquireMigrationLock` call.
+     */
     releaseMigrationLock(db: Kysely<any>): Promise<void>;
 }

package/dist/cjs/dialect/mysql/mysql-adapter.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MysqlAdapter = void 0;
+const dialect_adapter_base_js_1 = require("../dialect-adapter-base.js");
 const LOCK_ID = 'ea586330-2c93-47c8-908d-981d9d270f9d';
 const LOCK_TIMEOUT_SECONDS = 60 * 60;
-class MysqlAdapter {
+class MysqlAdapter extends dialect_adapter_base_js_1.DialectAdapterBase {
     get supportsTransactionalDdl() {
         return false;
     }

package/dist/cjs/dialect/mysql/mysql-dialect.d.ts

@@ -15,9 +15,25 @@ import { DatabaseConnection } from '../../driver/database-connection.js';
 export declare class MysqlDialect implements Dialect {
     #private;
     constructor(config: MysqlDialectConfig);
+    /**
+     * Creates a driver for the dialect.
+     */
     createDriver(): Driver;
+    /**
+     * Creates a query compiler for the dialect.
+     */
     createQueryCompiler(): QueryCompiler;
+    /**
+     * Creates an adapter for the dialect.
+     */
     createAdapter(): DialectAdapter;
+    /**
+     * Creates a database introspector that can be used to get the database metadata
+     * such as the tables and columns that exist in the database.
+     *
+     * `db` never has any plugins installed. It's created using
+     * {@link Kysely.withoutPlugins}.
+     */
     createIntrospector(db: Kysely<any>): DatabaseIntrospector;
 }
 /**

package/dist/cjs/dialect/mysql/mysql-driver.d.ts

@@ -4,11 +4,40 @@ import { MysqlDialectConfig } from './mysql-dialect.js';
 export declare class MysqlDriver implements Driver {
     #private;
     constructor(config: MysqlDialectConfig);
+    /**
+     * Initializes the driver.
+     *
+     * After calling this method the driver should be usable and `acquireConnection` etc.
+     * methods should be callable.
+     *
+     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
+     * should be imported inside this function, not at the top of the driver file! This is
+     * important so that Kysely is usable without installing all database driver libraries
+     * it supports.
+     */
     init(): Promise<void>;
+    /**
+     * Acquires a new connection from the pool.
+     */
     acquireConnection(): Promise<DatabaseConnection>;
+    /**
+     * Begins a transaction.
+     */
     beginTransaction(connection: DatabaseConnection, settings: TransactionSettings): Promise<void>;
+    /**
+     * Commits a transaction.
+     */
     commitTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Rolls back a transaction.
+     */
     rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Releases a connection back to the pool.
+     */
     releaseConnection(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Destroys the driver and releases all resources.
+     */
     destroy(): Promise<void>;
 }

package/dist/cjs/dialect/mysql/mysql-introspector.d.ts

@@ -3,5 +3,8 @@ import { Kysely } from '../../kysely.js';
 export declare class MysqlIntrospector implements DatabaseIntrospector {
     #private;
     constructor(db: Kysely<any>);
+    /**
+     * Get the database metadata such as the names of the tables and columns.
+     */
     getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
 }

package/dist/cjs/dialect/postgres/postgres-adapter.d.ts

@@ -1,8 +1,44 @@
 import { Kysely } from '../../kysely.js';
-import { DialectAdapter } from '../dialect-adapter.js';
-export declare class PostgresAdapter implements DialectAdapter {
+import { DialectAdapterBase } from '../dialect-adapter-base.js';
+export declare class PostgresAdapter extends DialectAdapterBase {
+    /**
+     * Whether or not this dialect supports transactional DDL.
+     *
+     * If this is true, migrations are executed inside a transaction.
+     */
     get supportsTransactionalDdl(): boolean;
+    /**
+     * Whether or not this dialect supports the `returning` in inserts
+     * updates and deletes.
+     */
     get supportsReturning(): boolean;
+    /**
+     * This method is used to acquire a lock for the migrations so that
+     * it's not possible for two migration processes to run in parallel.
+     *
+     * Most dialects have explicit locks that can be used, like advisory locks
+     * in PostgreSQL and the get_lock function in MySQL.
+     *
+     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
+     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
+     * has two columns `id` and `is_locked` and there's only one row in the
+     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
+     * Kysely takes care of creating the lock table and inserting the one single
+     * row to it before this method is executed.
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations will be executed. Otherwise
+     * `db` is a single connection (session) that will be used to execute the
+     * migrations.
+     */
     acquireMigrationLock(db: Kysely<any>): Promise<void>;
+    /**
+     * Releases the migration lock. See {@link acquireMigrationLock}.
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations were executed. Otherwise `db`
+     * is a single connection (session) that was used to execute the migrations
+     * and the `acquireMigrationLock` call.
+     */
     releaseMigrationLock(): Promise<void>;
 }

package/dist/cjs/dialect/postgres/postgres-adapter.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresAdapter = void 0;
+const dialect_adapter_base_js_1 = require("../dialect-adapter-base.js");
 // Random id for our transaction lock.
 const LOCK_ID = '3853314791062309107';
-class PostgresAdapter {
+class PostgresAdapter extends dialect_adapter_base_js_1.DialectAdapterBase {
     get supportsTransactionalDdl() {
         return true;
     }

package/dist/cjs/dialect/postgres/postgres-dialect.d.ts

@@ -21,9 +21,25 @@ import { DatabaseConnection } from '../../driver/database-connection.js';
 export declare class PostgresDialect implements Dialect {
     #private;
     constructor(config: PostgresDialectConfig);
+    /**
+     * Creates a driver for the dialect.
+     */
     createDriver(): Driver;
+    /**
+     * Creates a query compiler for the dialect.
+     */
     createQueryCompiler(): QueryCompiler;
+    /**
+     * Creates an adapter for the dialect.
+     */
     createAdapter(): DialectAdapter;
+    /**
+     * Creates a database introspector that can be used to get the database metadata
+     * such as the tables and columns that exist in the database.
+     *
+     * `db` never has any plugins installed. It's created using
+     * {@link Kysely.withoutPlugins}.
+     */
     createIntrospector(db: Kysely<any>): DatabaseIntrospector;
 }
 /**

package/dist/cjs/dialect/postgres/postgres-driver.d.ts

@@ -4,11 +4,40 @@ import { PostgresDialectConfig } from './postgres-dialect.js';
 export declare class PostgresDriver implements Driver {
     #private;
     constructor(config: PostgresDialectConfig);
+    /**
+     * Initializes the driver.
+     *
+     * After calling this method the driver should be usable and `acquireConnection` etc.
+     * methods should be callable.
+     *
+     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
+     * should be imported inside this function, not at the top of the driver file! This is
+     * important so that Kysely is usable without installing all database driver libraries
+     * it supports.
+     */
     init(): Promise<void>;
+    /**
+     * Acquires a new connection from the pool.
+     */
     acquireConnection(): Promise<DatabaseConnection>;
+    /**
+     * Begins a transaction.
+     */
     beginTransaction(connection: DatabaseConnection, settings: TransactionSettings): Promise<void>;
+    /**
+     * Commits a transaction.
+     */
     commitTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Rolls back a transaction.
+     */
     rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Releases a connection back to the pool.
+     */
     releaseConnection(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Destroys the driver and releases all resources.
+     */
     destroy(): Promise<void>;
 }

package/dist/cjs/dialect/postgres/postgres-introspector.d.ts

@@ -3,5 +3,8 @@ import { Kysely } from '../../kysely.js';
 export declare class PostgresIntrospector implements DatabaseIntrospector {
     #private;
     constructor(db: Kysely<any>);
+    /**
+     * Get the database metadata such as the names of the tables and columns.
+     */
     getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
 }

package/dist/cjs/dialect/sqlite/sqlite-adapter.d.ts

@@ -1,7 +1,43 @@
-import { DialectAdapter } from '../dialect-adapter.js';
-export declare class SqliteAdapter implements DialectAdapter {
+import { DialectAdapterBase } from '../dialect-adapter-base.js';
+export declare class SqliteAdapter implements DialectAdapterBase {
+    /**
+     * Whether or not this dialect supports transactional DDL.
+     *
+     * If this is true, migrations are executed inside a transaction.
+     */
     get supportsTransactionalDdl(): boolean;
+    /**
+     * Whether or not this dialect supports the `returning` in inserts
+     * updates and deletes.
+     */
     get supportsReturning(): boolean;
+    /**
+     * This method is used to acquire a lock for the migrations so that
+     * it's not possible for two migration processes to run in parallel.
+     *
+     * Most dialects have explicit locks that can be used, like advisory locks
+     * in PostgreSQL and the get_lock function in MySQL.
+     *
+     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
+     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
+     * has two columns `id` and `is_locked` and there's only one row in the
+     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
+     * Kysely takes care of creating the lock table and inserting the one single
+     * row to it before this method is executed.
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations will be executed. Otherwise
+     * `db` is a single connection (session) that will be used to execute the
+     * migrations.
+     */
     acquireMigrationLock(): Promise<void>;
+    /**
+     * Releases the migration lock. See {@link acquireMigrationLock}.
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations were executed. Otherwise `db`
+     * is a single connection (session) that was used to execute the migrations
+     * and the `acquireMigrationLock` call.
+     */
     releaseMigrationLock(): Promise<void>;
 }

package/dist/cjs/dialect/sqlite/sqlite-dialect.d.ts

@@ -15,9 +15,25 @@ import { DatabaseConnection } from '../../driver/database-connection.js';
 export declare class SqliteDialect implements Dialect {
     #private;
     constructor(config: SqliteDialectConfig);
+    /**
+     * Creates a driver for the dialect.
+     */
     createDriver(): Driver;
+    /**
+     * Creates a query compiler for the dialect.
+     */
     createQueryCompiler(): QueryCompiler;
+    /**
+     * Creates an adapter for the dialect.
+     */
     createAdapter(): DialectAdapter;
+    /**
+     * Creates a database introspector that can be used to get the database metadata
+     * such as the tables and columns that exist in the database.
+     *
+     * `db` never has any plugins installed. It's created using
+     * {@link Kysely.withoutPlugins}.
+     */
     createIntrospector(db: Kysely<any>): DatabaseIntrospector;
 }
 /**

package/dist/cjs/dialect/sqlite/sqlite-driver.d.ts

@@ -4,11 +4,40 @@ import { SqliteDialectConfig } from './sqlite-dialect.js';
 export declare class SqliteDriver implements Driver {
     #private;
     constructor(config: SqliteDialectConfig);
+    /**
+     * Initializes the driver.
+     *
+     * After calling this method the driver should be usable and `acquireConnection` etc.
+     * methods should be callable.
+     *
+     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
+     * should be imported inside this function, not at the top of the driver file! This is
+     * important so that Kysely is usable without installing all database driver libraries
+     * it supports.
+     */
     init(): Promise<void>;
+    /**
+     * Acquires a new connection from the pool.
+     */
     acquireConnection(): Promise<DatabaseConnection>;
+    /**
+     * Begins a transaction.
+     */
     beginTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Commits a transaction.
+     */
     commitTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Rolls back a transaction.
+     */
     rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Releases a connection back to the pool.
+     */
     releaseConnection(): Promise<void>;
+    /**
+     * Destroys the driver and releases all resources.
+     */
     destroy(): Promise<void>;
 }

package/dist/cjs/dialect/sqlite/sqlite-introspector.d.ts

@@ -3,5 +3,8 @@ import { Kysely } from '../../kysely.js';
 export declare class SqliteIntrospector implements DatabaseIntrospector {
     #private;
     constructor(db: Kysely<any>);
+    /**
+     * Get the database metadata such as the names of the tables and columns.
+     */
     getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
 }

package/dist/cjs/driver/default-connection-provider.d.ts

@@ -4,5 +4,9 @@ import { Driver } from './driver.js';
 export declare class DefaultConnectionProvider implements ConnectionProvider {
     #private;
     constructor(driver: Driver);
+    /**
+     * Provides a connection for the callback and takes care of disposing
+     * the connection after the callback has been run.
+     */
     withConnection<T>(runner: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
 }

package/dist/cjs/driver/runtime-driver.d.ts

@@ -9,11 +9,40 @@ import { Driver, TransactionSettings } from './driver.js';
 export declare class RuntimeDriver implements Driver {
     #private;
     constructor(driver: Driver, log: Log);
+    /**
+     * Initializes the driver.
+     *
+     * After calling this method the driver should be usable and `acquireConnection` etc.
+     * methods should be callable.
+     *
+     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
+     * should be imported inside this function, not at the top of the driver file! This is
+     * important so that Kysely is usable without installing all database driver libraries
+     * it supports.
+     */
     init(): Promise<void>;
+    /**
+     * Acquires a new connection from the pool.
+     */
     acquireConnection(): Promise<DatabaseConnection>;
+    /**
+     * Releases a connection back to the pool.
+     */
     releaseConnection(runtimeConnection: DatabaseConnection): Promise<void>;
+    /**
+     * Begins a transaction.
+     */
     beginTransaction(connection: DatabaseConnection, settings: TransactionSettings): Promise<void>;
+    /**
+     * Commits a transaction.
+     */
     commitTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Rolls back a transaction.
+     */
     rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Destroys the driver and releases all resources.
+     */
     destroy(): Promise<void>;
 }

package/dist/cjs/driver/single-connection-provider.d.ts

@@ -3,5 +3,9 @@ import { ConnectionProvider } from './connection-provider.js';
 export declare class SingleConnectionProvider implements ConnectionProvider {
     #private;
     constructor(connection: DatabaseConnection);
+    /**
+     * Provides a connection for the callback and takes care of disposing
+     * the connection after the callback has been run.
+     */
     withConnection<T>(runner: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
 }

package/dist/cjs/dynamic/dynamic-reference-builder.d.ts

@@ -16,3 +16,4 @@ export declare class DynamicReferenceBuilder<R extends string = never> implement
     constructor(reference: string);
     toOperationNode(): ReferenceNode | ColumnNode;
 }
+export declare function isDynamicReferenceBuilder(obj: unknown): obj is DynamicReferenceBuilder<any>;

package/dist/cjs/dynamic/dynamic-reference-builder.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DynamicReferenceBuilder = void 0;
+exports.isDynamicReferenceBuilder = exports.DynamicReferenceBuilder = void 0;
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const reference_parser_js_1 = require("../parser/reference-parser.js");
+const object_utils_js_1 = require("../util/object-utils.js");
 class DynamicReferenceBuilder {
     #dynamicReference;
     get dynamicReference() {
@@ -26,3 +28,9 @@ class DynamicReferenceBuilder {
     }
 }
 exports.DynamicReferenceBuilder = DynamicReferenceBuilder;
+function isDynamicReferenceBuilder(obj) {
+    return ((0, object_utils_js_1.isObject)(obj) &&
+        (0, operation_node_source_js_1.isOperationNodeSource)(obj) &&
+        (0, object_utils_js_1.isString)(obj.dynamicReference));
+}
+exports.isDynamicReferenceBuilder = isDynamicReferenceBuilder;

package/dist/cjs/dynamic/dynamic.d.ts

@@ -20,7 +20,8 @@ export declare class DynamicModule {
      * `ref` to other methods as well. If the types allow you to pass a `ref`
      * value to some place, it should work.
      *
-     * @example
+     * ### Examples
+     *
      * Filter by a column not know at compile time:
      *
      * ```ts
@@ -38,7 +39,6 @@ export declare class DynamicModule {
      * someQuery('person.last_name', 'Aniston')
      * ```
      *
-     * @example
      * Order by a column not know at compile time:
      *
      * ```ts
@@ -55,7 +55,6 @@ export declare class DynamicModule {
      * someQuery('fn')
      * ```
      *
-     * @example
      * In this example we add selections dynamically:
      *
      * ```ts
@@ -66,7 +65,7 @@ export declare class DynamicModule {
      *
      * // A type that lists all possible values `columnFromUserInput` can have.
      * // You can use `keyof Person` if any column of an interface is allowed.
-     * type PossibleColumns = 'last_name' | 'first_name' | 'birth_date'
+     * type PossibleColumns = 'last_name' | 'first_name' | 'birth_date'
      *
      * const [person] = await db.selectFrom('person')
      *   .select([
@@ -78,9 +77,9 @@ export declare class DynamicModule {
      * // The resulting type contains all `PossibleColumns` as optional fields
      * // because we cannot know which field was actually selected before
      * // running the code.
-     * const lastName: string | undefined = person.last_name
-     * const firstName: string | undefined = person.first_name
-     * const birthDate: string | undefined = person.birth_date
+     * const lastName: string | undefined = person.last_name
+     * const firstName: string | undefined = person.first_name
+     * const birthDate: string | undefined = person.birth_date
      *
      * // The result type also contains the compile time selection `id`.
      * person.id