rwsdk 0.1.16 → 0.1.17

package/dist/runtime/lib/db/DOWorkerDialect.js

@@ -0,0 +1,66 @@
+import debug from "../debug";
+import { SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler, } from "kysely";
+const log = debug("sdk:db:do-worker-dialect");
+export class DOWorkerDialect {
+    constructor(config) {
+        this.config = config;
+    }
+    createAdapter() {
+        return new SqliteAdapter();
+    }
+    createDriver() {
+        return new DOWorkerDriver(this.config);
+    }
+    createQueryCompiler() {
+        return new SqliteQueryCompiler();
+    }
+    createIntrospector(db) {
+        return new SqliteIntrospector(db);
+    }
+}
+class DOWorkerDriver {
+    constructor(config) {
+        this.config = config;
+    }
+    async init() { }
+    async acquireConnection() {
+        return new DOWorkerConnection(this.config.stub.kyselyExecuteQuery);
+    }
+    async beginTransaction(conn) {
+        return await conn.beginTransaction();
+    }
+    async commitTransaction(conn) {
+        return await conn.commitTransaction();
+    }
+    async rollbackTransaction(conn) {
+        return await conn.rollbackTransaction();
+    }
+    async releaseConnection(_conn) { }
+    async destroy() { }
+}
+class DOWorkerConnection {
+    constructor(executeQuery) {
+        this._executeQuery = executeQuery;
+    }
+    async executeQuery(compiledQuery) {
+        log("Forwarding query to Durable Object: %s", compiledQuery.sql);
+        // Call the DO's kyselyExecuteQuery method
+        const result = await this._executeQuery({
+            sql: compiledQuery.sql,
+            parameters: compiledQuery.parameters,
+        });
+        return result;
+    }
+    async beginTransaction() {
+        throw new Error("Transactions are not supported yet.");
+    }
+    async commitTransaction() {
+        throw new Error("Transactions are not supported yet.");
+    }
+    async rollbackTransaction() {
+        throw new Error("Transactions are not supported yet.");
+    }
+    async *streamQuery(_compiledQuery, _chunkSize) {
+        throw new Error("DO Driver does not support streaming");
+    }
+}

package/dist/runtime/lib/db/SqliteDurableObject.d.ts

@@ -0,0 +1,14 @@
+import { DurableObject } from "cloudflare:workers";
+import { Kysely, QueryResult } from "kysely";
+export declare class SqliteDurableObject<T = any> extends DurableObject {
+    migrations: Record<string, any>;
+    kysely: Kysely<T>;
+    private initialized;
+    private migrationTableName;
+    constructor(ctx: DurableObjectState, env: any, migrations: Record<string, any>, migrationTableName?: string);
+    initialize(): Promise<void>;
+    kyselyExecuteQuery<R>(compiledQuery: {
+        sql: string;
+        parameters: readonly unknown[];
+    }): Promise<QueryResult<R>>;
+}

package/dist/runtime/lib/db/SqliteDurableObject.js

@@ -0,0 +1,42 @@
+import { DODialect } from "kysely-do";
+import { DurableObject } from "cloudflare:workers";
+import { Kysely } from "kysely";
+import { createMigrator } from "./index.js";
+import debug from "../debug.js";
+const log = debug("sdk:do-db");
+// Base class for Durable Objects that need Kysely database access
+export class SqliteDurableObject extends DurableObject {
+    constructor(ctx, env, migrations, migrationTableName = "__migrations") {
+        super(ctx, env);
+        this.initialized = false;
+        this.migrations = migrations;
+        this.migrationTableName = migrationTableName;
+        this.kysely = new Kysely({
+            dialect: new DODialect({ ctx }),
+        });
+    }
+    async initialize() {
+        if (this.initialized) {
+            log("Database already initialized, skipping");
+            return;
+        }
+        log("Initializing Durable Object database");
+        const migrator = createMigrator(this.kysely, this.migrations, this.migrationTableName);
+        await migrator.migrateToLatest();
+        this.initialized = true;
+        log("Database initialization complete");
+    }
+    // RPC method for executing queries - must be on prototype for RPC to work
+    async kyselyExecuteQuery(compiledQuery) {
+        await this.initialize();
+        log("Executing SQL: %s with params: %o", compiledQuery.sql, compiledQuery.parameters);
+        // Forward to the internal Kysely database
+        const result = await this.kysely.executeQuery({
+            sql: compiledQuery.sql,
+            parameters: compiledQuery.parameters,
+            query: {},
+            queryId: {},
+        });
+        return result;
+    }
+}

package/dist/runtime/lib/db/createDb.d.ts

@@ -0,0 +1,2 @@
+import { Kysely } from "kysely";
+export declare function createDb<T>(durableObjectBinding: any, name?: string): Kysely<T>;

package/dist/runtime/lib/db/createDb.js

@@ -0,0 +1,33 @@
+import { Kysely } from "kysely";
+import { requestInfo } from "../../requestInfo/worker.js";
+import { DOWorkerDialect } from "./DOWorkerDialect.js";
+const createDurableObjectDb = (durableObjectBinding, name = "main") => {
+    const durableObjectId = durableObjectBinding.idFromName(name);
+    const stub = durableObjectBinding.get(durableObjectId);
+    stub.initialize();
+    return new Kysely({
+        dialect: new DOWorkerDialect({ stub }),
+    });
+};
+export function createDb(durableObjectBinding, name = "main") {
+    const cacheKey = `${durableObjectBinding}_${name}`;
+    const doCreateDb = () => {
+        let db = requestInfo.rw.databases.get(cacheKey);
+        if (!db) {
+            db = createDurableObjectDb(durableObjectBinding, name);
+            requestInfo.rw.databases.set(cacheKey, db);
+        }
+        return db;
+    };
+    doCreateDb();
+    return new Proxy({}, {
+        get(target, prop, receiver) {
+            const db = doCreateDb();
+            const value = db[prop];
+            if (typeof value === "function") {
+                return value.bind(db);
+            }
+            return value;
+        },
+    });
+}

package/dist/runtime/lib/db/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./migrations.js";
+export * from "./SqliteDurableObject.js";
+export * from "./createDb.js";
+export type * from "./typeInference/database.js";

package/dist/runtime/lib/db/index.js

@@ -0,0 +1,3 @@
+export * from "./migrations.js";
+export * from "./SqliteDurableObject.js";
+export * from "./createDb.js";

package/dist/runtime/lib/db/migrations.d.ts

@@ -0,0 +1,23 @@
+import { Kysely, Migration, Migrator, MigrationProvider } from "kysely";
+/**
+ * A custom MigrationProvider that works with in-memory migrations
+ * rather than reading from files.
+ */
+export declare class InMemoryMigrationProvider implements MigrationProvider {
+    private migrations;
+    constructor(migrations: Record<string, Migration>);
+    getMigrations(): Promise<Record<string, Migration>>;
+}
+/**
+ * Helper function to create a migrator using Kysely's built-in Migrator.
+ *
+ * @example
+ * ```typescript
+ * const migrator = createMigrator(db, migrations, "__my_migrations");
+ * const result = await migrator.migrateToLatest();
+ * if (result.error) {
+ *   throw new Error(`Migration failed: ${result.error}`);
+ * }
+ * ```
+ */
+export declare function createMigrator(db: Kysely<any>, migrations: Record<string, Migration>, migrationTableName?: string): Migrator;

package/dist/runtime/lib/db/migrations.js

@@ -0,0 +1,34 @@
+import { Migrator } from "kysely";
+/**
+ * A custom MigrationProvider that works with in-memory migrations
+ * rather than reading from files.
+ */
+export class InMemoryMigrationProvider {
+    constructor(migrations) {
+        this.migrations = migrations;
+    }
+    async getMigrations() {
+        return this.migrations;
+    }
+}
+/**
+ * Helper function to create a migrator using Kysely's built-in Migrator.
+ *
+ * @example
+ * ```typescript
+ * const migrator = createMigrator(db, migrations, "__my_migrations");
+ * const result = await migrator.migrateToLatest();
+ * if (result.error) {
+ *   throw new Error(`Migration failed: ${result.error}`);
+ * }
+ * ```
+ */
+export function createMigrator(db, migrations, migrationTableName = "__rwsdk_migrations") {
+    return new Migrator({
+        db,
+        provider: new InMemoryMigrationProvider(migrations),
+        migrationTableName,
+        // Use a custom lock table name based on the migration table name
+        migrationLockTableName: `${migrationTableName}_lock`,
+    });
+}

package/dist/runtime/lib/db/typeInference/assert.d.ts

@@ -0,0 +1,2 @@
+export type AssertStillImplements<OurBuilder, KyselyBuilder> = keyof KyselyBuilder extends keyof OurBuilder ? true : false;
+export type Assert<T extends true> = T;

package/dist/runtime/lib/db/typeInference/assert.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/db/typeInference/builders/alterColumn.d.ts

@@ -0,0 +1,27 @@
+import { AlterColumnNode } from "kysely";
+import { Alteration } from "../utils";
+export interface AlteredColumnBuilder<TAlteration extends Alteration> {
+    readonly __alteration: TAlteration;
+    toOperationNode(): AlterColumnNode;
+}
+export interface AlterColumnBuilder {
+    setDataType<T extends string>(dataType: T): AlteredColumnBuilder<{
+        kind: "setDataType";
+        dataType: T;
+    }>;
+    setDefault<T>(value: T): AlteredColumnBuilder<{
+        kind: "setDefault";
+        value: T;
+    }>;
+    dropDefault(): AlteredColumnBuilder<{
+        kind: "dropDefault";
+    }>;
+    setNotNull(): AlteredColumnBuilder<{
+        kind: "setNotNull";
+    }>;
+    dropNotNull(): AlteredColumnBuilder<{
+        kind: "dropNotNull";
+    }>;
+    $call<T>(func: (qb: this) => T): T;
+}
+export type AlterColumnBuilderCallback = (builder: AlterColumnBuilder) => AlteredColumnBuilder<any>;

package/dist/runtime/lib/db/typeInference/builders/alterColumn.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/db/typeInference/builders/alterTable.d.ts

@@ -0,0 +1,53 @@
+import { SqlToTsType, ExecutedBuilder, AlterOperation, AddColumnOp, DropColumnOp, RenameColumnOp, AlterColumnOp, ModifyColumnOp } from "../utils";
+import { ColumnDefinitionBuilder } from "./columnDefinition";
+import { AlterColumnBuilderCallback } from "./alterColumn";
+import { ForeignKeyConstraintBuilder, Expression, CheckConstraintNode, UniqueConstraintNode, PrimaryKeyConstraintNode, sql } from "kysely";
+type DataTypeExpression = string | typeof sql;
+interface CheckConstraintBuilder {
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): CheckConstraintNode;
+}
+interface UniqueConstraintBuilder {
+    nullsNotDistinct(): UniqueConstraintBuilder;
+    deferrable(): UniqueConstraintBuilder;
+    notDeferrable(): UniqueConstraintBuilder;
+    initiallyDeferred(): UniqueConstraintBuilder;
+    initiallyImmediate(): UniqueConstraintBuilder;
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): UniqueConstraintNode;
+}
+interface PrimaryKeyConstraintBuilder {
+    deferrable(): PrimaryKeyConstraintBuilder;
+    notDeferrable(): PrimaryKeyConstraintBuilder;
+    initiallyDeferred(): PrimaryKeyConstraintBuilder;
+    initiallyImmediate(): PrimaryKeyConstraintBuilder;
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): PrimaryKeyConstraintNode;
+}
+export interface AlterTableBuilder<TName extends string, TOps extends AlterOperation[] = []> {
+    readonly __tableName: TName;
+    readonly __operations: TOps;
+    renameTo<TNewName extends string>(newTableName: TNewName): AlterTableBuilder<TNewName, TOps> & {
+        readonly __renamedFrom: TName;
+    };
+    setSchema(newSchema: string): AlterTableBuilder<TName, TOps>;
+    addColumn<K extends string, T extends DataTypeExpression>(name: K, type: T, build?: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>>): AlterTableBuilder<TName, [...TOps, AddColumnOp<K, T>]>;
+    dropColumn<K extends string>(name: K): AlterTableBuilder<TName, [...TOps, DropColumnOp<K>]>;
+    renameColumn<KFrom extends string, KTo extends string>(from: KFrom, to: KTo): AlterTableBuilder<TName, [...TOps, RenameColumnOp<KFrom, KTo>]>;
+    alterColumn<K extends string, const TCallback extends AlterColumnBuilderCallback>(column: K, alteration: TCallback): AlterTableBuilder<TName, [
+        ...TOps,
+        AlterColumnOp<K, ReturnType<TCallback>["__alteration"]>
+    ]>;
+    modifyColumn<K extends string, T extends DataTypeExpression>(column: K, type: T, build?: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>>): AlterTableBuilder<TName, [...TOps, ModifyColumnOp<K, T>]>;
+    addUniqueConstraint(constraintName: string, columns: string[], build?: (builder: UniqueConstraintBuilder) => UniqueConstraintBuilder): AlterTableBuilder<TName, TOps>;
+    addPrimaryKeyConstraint(constraintName: string, columns: string[], build?: (builder: PrimaryKeyConstraintBuilder) => PrimaryKeyConstraintBuilder): AlterTableBuilder<TName, TOps>;
+    addCheckConstraint(constraintName: string, checkExpression: Expression<any>, build?: (builder: CheckConstraintBuilder) => CheckConstraintBuilder): AlterTableBuilder<TName, TOps>;
+    addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[], build?: (builder: ForeignKeyConstraintBuilder) => ForeignKeyConstraintBuilder): AlterTableBuilder<TName, TOps>;
+    dropConstraint(constraintName: string): AlterTableBuilder<TName, TOps>;
+    renameConstraint(oldName: string, newName: string): AlterTableBuilder<TName, TOps>;
+    addIndex(indexName: string): AlterTableBuilder<TName, TOps>;
+    dropIndex(indexName: string): AlterTableBuilder<TName, TOps>;
+    execute(): Promise<ExecutedBuilder<this>>;
+    $call<T>(func: (qb: this) => T): T;
+}
+export {};

package/dist/runtime/lib/db/typeInference/builders/alterTable.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/db/typeInference/builders/columnDefinition.d.ts

@@ -0,0 +1,26 @@
+import { Expression, sql, ColumnDefinitionNode } from "kysely";
+type DefaultValueExpression = string | number | boolean | null | typeof sql;
+export interface ColumnDefinitionBuilder<TType> {
+    autoIncrement(): ColumnDefinitionBuilder<TType>;
+    identity(): ColumnDefinitionBuilder<TType>;
+    primaryKey(): ColumnDefinitionBuilder<TType>;
+    references(ref: string): ColumnDefinitionBuilder<TType>;
+    onDelete(onDelete: "no action" | "restrict" | "cascade" | "set null" | "set default"): ColumnDefinitionBuilder<TType>;
+    onUpdate(onUpdate: "no action" | "restrict" | "cascade" | "set null" | "set default"): ColumnDefinitionBuilder<TType>;
+    unique(): ColumnDefinitionBuilder<TType>;
+    notNull(): ColumnDefinitionBuilder<TType>;
+    unsigned(): ColumnDefinitionBuilder<TType>;
+    defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder<TType>;
+    check(expression: Expression<any>): ColumnDefinitionBuilder<TType>;
+    generatedAlwaysAs(expression: Expression<any>): ColumnDefinitionBuilder<TType>;
+    generatedAlwaysAsIdentity(): ColumnDefinitionBuilder<TType>;
+    generatedByDefaultAsIdentity(): ColumnDefinitionBuilder<TType>;
+    stored(): ColumnDefinitionBuilder<TType>;
+    modifyFront(modifier: Expression<any>): ColumnDefinitionBuilder<TType>;
+    nullsNotDistinct(): ColumnDefinitionBuilder<TType>;
+    ifNotExists(): ColumnDefinitionBuilder<TType>;
+    modifyEnd(modifier: Expression<any>): ColumnDefinitionBuilder<TType>;
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): ColumnDefinitionNode;
+}
+export {};

package/dist/runtime/lib/db/typeInference/builders/columnDefinition.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/db/typeInference/builders/createTable.d.ts

@@ -0,0 +1,49 @@
+import { SqlToTsType, ExecutedBuilder, Prettify } from "../utils";
+import { ColumnDefinitionBuilder } from "./columnDefinition";
+import { CompiledQuery, CreateTableNode, Expression, ForeignKeyConstraintBuilder, CheckConstraintNode, UniqueConstraintNode, PrimaryKeyConstraintNode } from "kysely";
+interface CheckConstraintBuilder {
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): CheckConstraintNode;
+}
+interface UniqueConstraintBuilder {
+    nullsNotDistinct(): UniqueConstraintBuilder;
+    deferrable(): UniqueConstraintBuilder;
+    notDeferrable(): UniqueConstraintBuilder;
+    initiallyDeferred(): UniqueConstraintBuilder;
+    initiallyImmediate(): UniqueConstraintBuilder;
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): UniqueConstraintNode;
+}
+interface PrimaryKeyConstraintBuilder {
+    deferrable(): PrimaryKeyConstraintBuilder;
+    notDeferrable(): PrimaryKeyConstraintBuilder;
+    initiallyDeferred(): PrimaryKeyConstraintBuilder;
+    initiallyImmediate(): PrimaryKeyConstraintBuilder;
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): PrimaryKeyConstraintNode;
+}
+export interface CreateTableBuilder<TName extends string, TSchema extends Record<string, any> = {}> {
+    readonly __tableName: TName;
+    readonly __addedColumns: TSchema;
+    temporary(): CreateTableBuilder<TName, TSchema>;
+    onCommit(onCommit: "preserve rows" | "delete rows" | "drop"): CreateTableBuilder<TName, TSchema>;
+    ifNotExists(): CreateTableBuilder<TName, TSchema>;
+    addColumn<K extends string, T extends string>(name: K, type: T, build?: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>>): CreateTableBuilder<TName, Prettify<(TSchema extends Record<string, any> ? TSchema : {}) & Record<K, SqlToTsType<T>>>>;
+    addUniqueConstraint(constraintName: string, columns: (keyof TSchema)[], build?: (builder: UniqueConstraintBuilder) => UniqueConstraintBuilder): CreateTableBuilder<TName, TSchema>;
+    addPrimaryKeyConstraint(constraintName: string, columns: (keyof TSchema)[], build?: (builder: PrimaryKeyConstraintBuilder) => PrimaryKeyConstraintBuilder): CreateTableBuilder<TName, TSchema>;
+    addCheckConstraint(constraintName: string, checkExpression: Expression<any>, build?: (builder: CheckConstraintBuilder) => CheckConstraintBuilder): CreateTableBuilder<TName, TSchema>;
+    addForeignKeyConstraint(constraintName: string, columns: (keyof TSchema)[], targetTable: string, targetColumns: string[], build?: (builder: ForeignKeyConstraintBuilder) => ForeignKeyConstraintBuilder): CreateTableBuilder<TName, TSchema>;
+    modifyFront(modifier: Expression<any>): CreateTableBuilder<TName, TSchema>;
+    modifyEnd(modifier: Expression<any>): CreateTableBuilder<TName, TSchema>;
+    as(expression: Expression<any>): CreateTableBuilder<TName, TSchema>;
+    execute(): Promise<ExecutedBuilder<this>>;
+    $call<T>(func: (qb: this) => T): T;
+    compile(): CompiledQuery;
+    toOperationNode(): CreateTableNode;
+    withSchema(schema: string): CreateTableBuilder<TName, TSchema>;
+    ownerTo(owner: string): CreateTableBuilder<TName, TSchema>;
+    replace(): CreateTableBuilder<TName, TSchema>;
+    ignore(): CreateTableBuilder<TName, TSchema>;
+    withoutTableConstraintValidation(): CreateTableBuilder<TName, TSchema>;
+}
+export {};

package/dist/runtime/lib/db/typeInference/builders/createTable.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/db/typeInference/builders/createView.d.ts

@@ -0,0 +1,17 @@
+import { ExecutedBuilder } from "../utils";
+import { CreateViewNode, CompiledQuery, SelectQueryBuilder, RawBuilder } from "kysely";
+export interface CreateViewBuilder<TName extends string, TSchema extends Record<string, any> = {}, TColumns extends string[] = []> {
+    readonly __viewName: TName;
+    readonly __schema: TSchema;
+    readonly __columns: TColumns;
+    temporary(): CreateViewBuilder<TName, TSchema, TColumns>;
+    orReplace(): CreateViewBuilder<TName, TSchema, TColumns>;
+    ifNotExists(): CreateViewBuilder<TName, TSchema, TColumns>;
+    columns<C extends string[]>(columns: C): CreateViewBuilder<TName, TSchema, C>;
+    as(query: SelectQueryBuilder<any, any, any> | RawBuilder<any>): CreateViewBuilder<TName, TSchema, TColumns>;
+    execute(): Promise<ExecutedBuilder<this>>;
+    toOperationNode(): CreateViewNode;
+    compile(): CompiledQuery;
+    $call<T>(func: (qb: this) => T): T;
+    materialized(): CreateViewBuilder<TName, TSchema, TColumns>;
+}

package/dist/runtime/lib/db/typeInference/builders/createView.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/db/typeInference/builders/dropTable.d.ts

@@ -0,0 +1,11 @@
+import { ExecutedBuilder } from "../utils";
+import { DropTableNode, CompiledQuery } from "kysely";
+export interface DropTableBuilder<TName extends string> {
+    readonly __tableName: TName;
+    ifExists(): DropTableBuilder<TName>;
+    cascade(): DropTableBuilder<TName>;
+    execute(): Promise<ExecutedBuilder<this>>;
+    toOperationNode(): DropTableNode;
+    compile(): CompiledQuery;
+    $call<T>(func: (qb: this) => T): T;
+}

package/dist/runtime/lib/db/typeInference/builders/dropTable.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/db/typeInference/builders/dropView.d.ts

@@ -0,0 +1,12 @@
+import { ExecutedBuilder } from "../utils";
+import { DropViewNode, CompiledQuery } from "kysely";
+export interface DropViewBuilder<TName extends string> {
+    readonly __viewName: TName;
+    ifExists(): DropViewBuilder<TName>;
+    cascade(): DropViewBuilder<TName>;
+    execute(): Promise<ExecutedBuilder<this>>;
+    toOperationNode(): DropViewNode;
+    compile(): CompiledQuery;
+    $call<T>(func: (qb: this) => T): T;
+    materialized(): DropViewBuilder<TName>;
+}

package/dist/runtime/lib/db/typeInference/builders/dropView.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/db/typeInference/builders/schema.d.ts

@@ -0,0 +1,24 @@
+import { CreateTableBuilder } from "./createTable";
+import { AlterTableBuilder } from "./alterTable";
+import { DropTableBuilder } from "./dropTable";
+import { CreateViewBuilder } from "./createView";
+import { DropViewBuilder } from "./dropView";
+import { CreateIndexBuilder, DropIndexBuilder, CreateSchemaBuilder, DropSchemaBuilder, CreateTypeBuilder, DropTypeBuilder, KyselyPlugin, RefreshMaterializedViewBuilder } from "kysely";
+export interface SchemaBuilder {
+    createTable<TName extends string>(name: TName): CreateTableBuilder<TName, {}>;
+    alterTable<TName extends string>(name: TName): AlterTableBuilder<TName, []>;
+    dropTable<TName extends string>(name: TName): DropTableBuilder<TName>;
+    createView<TName extends string>(name: TName): CreateViewBuilder<TName, never>;
+    dropView<TName extends string>(name: TName): DropViewBuilder<TName>;
+    withSchema(schema: string): this;
+    createIndex(name: string): CreateIndexBuilder;
+    dropIndex(name: string): DropIndexBuilder;
+    createSchema(name: string): CreateSchemaBuilder;
+    dropSchema(name: string): DropSchemaBuilder;
+    createType(name: string): CreateTypeBuilder;
+    dropType(name: string): DropTypeBuilder;
+    refreshMaterializedView(viewName: string): RefreshMaterializedViewBuilder;
+    $call<T>(func: (qb: this) => T): T;
+    withPlugin(plugin: KyselyPlugin): this;
+    withoutPlugins(): this;
+}

package/dist/runtime/lib/db/typeInference/builders/schema.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/db/typeInference/database.d.ts

@@ -0,0 +1,27 @@
+import { Kysely } from "kysely";
+import { ExecutedBuilder, Prettify, ProcessAlteredTable, UnionToTuple } from "./utils";
+import { CreateTableBuilder } from "./builders/createTable";
+import { AlterTableBuilder } from "./builders/alterTable";
+import { DropTableBuilder } from "./builders/dropTable";
+import { SchemaBuilder } from "./builders/schema";
+export interface InferenceBuilder {
+    schema: SchemaBuilder;
+}
+export type MigrationBuilder = InferenceBuilder & Kysely<any>;
+export interface Migration<TUpReturn = unknown> {
+    up(db: MigrationBuilder): TUpReturn;
+    down?(db: Kysely<any>): any;
+}
+export type Migrations = Record<string, Migration>;
+type GetBuilder<T> = T extends ExecutedBuilder<infer B> ? B : never;
+type BuildersFromMigration<TMigration extends Migration> = TMigration extends Migration<infer TUpReturn> ? Awaited<TUpReturn> extends Array<infer Item> ? GetBuilder<Item> : GetBuilder<Awaited<TUpReturn>> : never;
+type ApplyBuilder<TSchema, TBuilder> = TBuilder extends CreateTableBuilder<infer TName, infer TSch> ? Prettify<TSchema & Record<TName, TSch>> : TBuilder extends DropTableBuilder<infer TName> ? Omit<TSchema, TName> : TBuilder extends AlterTableBuilder<infer TName, infer TOps> ? TBuilder extends {
+    __renamedFrom: infer From extends string;
+} ? From extends keyof TSchema ? Prettify<Omit<TSchema, From> & Record<TName, ProcessAlteredTable<TSchema[From], TOps>>> : TSchema : TName extends keyof TSchema ? Prettify<Omit<TSchema, TName> & Record<TName, ProcessAlteredTable<TSchema[TName], TOps>>> : TSchema : TSchema;
+type ApplyBuilders<TSchema, TBuildersTuple> = TBuildersTuple extends [
+    infer THead,
+    ...infer TRest
+] ? ApplyBuilders<ApplyBuilder<TSchema, THead>, TRest> : TSchema;
+type ProcessMigrations<TMigrations extends Migrations, TKeys, TSchema = {}> = TKeys extends [infer THeadKey, ...infer TRestKeys] ? THeadKey extends keyof TMigrations ? ProcessMigrations<TMigrations, TRestKeys, ApplyBuilders<TSchema, UnionToTuple<BuildersFromMigration<TMigrations[THeadKey]>>>> : TSchema : TSchema;
+export type Database<TMigrations extends Migrations = Migrations> = ProcessMigrations<TMigrations, UnionToTuple<keyof TMigrations>>;
+export {};

package/dist/runtime/lib/db/typeInference/database.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/db/typeInference/typetests/alterTable.typetest.d.ts

@@ -0,0 +1 @@
+export {};