rwsdk 1.0.0-beta.4 → 1.0.0-beta.41

package/dist/runtime/client/navigation.d.ts

@@ -4,6 +4,55 @@ export interface ClientNavigationOptions {
     scrollBehavior?: "auto" | "smooth" | "instant";
 }
 export declare function validateClickEvent(event: MouseEvent, target: HTMLElement): boolean;
+export interface NavigateOptions {
+    history?: "push" | "replace";
+    info?: {
+        scrollToTop?: boolean;
+        scrollBehavior?: "auto" | "smooth" | "instant";
+    };
+}
+export declare function navigate(href: string, options?: NavigateOptions): Promise<void>;
+/**
+ * Initializes client-side navigation for Single Page App (SPA) behavior.
+ *
+ * Intercepts clicks on internal links and fetches page content without full-page reloads.
+ * Returns a handleResponse function to pass to initClient.
+ *
+ * @param opts.scrollToTop - Scroll to top after navigation (default: true)
+ * @param opts.scrollBehavior - How to scroll: 'instant', 'smooth', or 'auto' (default: 'instant')
+ * @param opts.onNavigate - Callback executed after history push but before RSC fetch
+ *
+ * @example
+ * // Basic usage
+ * import { initClient, initClientNavigation } from "rwsdk/client";
+ *
+ * const { handleResponse } = initClientNavigation();
+ * initClient({ handleResponse });
+ *
+ * @example
+ * // With custom scroll behavior
+ * const { handleResponse } = initClientNavigation({
+ *   scrollBehavior: "smooth",
+ *   scrollToTop: true,
+ * });
+ * initClient({ handleResponse });
+ *
+ * @example
+ * // Preserve scroll position (e.g., for infinite scroll)
+ * const { handleResponse } = initClientNavigation({
+ *   scrollToTop: false,
+ * });
+ * initClient({ handleResponse });
+ *
+ * @example
+ * // With navigation callback
+ * const { handleResponse } = initClientNavigation({
+ *   onNavigate: () => {
+ *     console.log("Navigating to:", window.location.href);
+ *   },
+ * });
+ * initClient({ handleResponse });
+ */
 export declare function initClientNavigation(opts?: ClientNavigationOptions): {
     handleResponse: (response: Response) => boolean;
 };

package/dist/runtime/client/navigation.js

@@ -1,10 +1,3 @@
-function saveScrollPosition(x, y) {
-    window.history.replaceState({
-        ...window.history.state,
-        scrollX: x,
-        scrollY: y,
-    }, "", window.location.href);
-}
 export function validateClickEvent(event, target) {
     // should this only work for left click?
     if (event.button !== 0) {
@@ -37,19 +30,85 @@ export function validateClickEvent(event, target) {
     }
     return true;
 }
+let IS_CLIENT_NAVIGATION = false;
+export async function navigate(href, options = { history: "push" }) {
+    if (!IS_CLIENT_NAVIGATION) {
+        window.location.href = href;
+        return;
+    }
+    saveScrollPosition(window.scrollX, window.scrollY);
+    const url = window.location.origin + href;
+    if (options.history === "push") {
+        window.history.pushState({ path: href }, "", url);
+    }
+    else {
+        window.history.replaceState({ path: href }, "", url);
+    }
+    // @ts-expect-error
+    await globalThis.__rsc_callServer();
+    const scrollToTop = options.info?.scrollToTop ?? true;
+    const scrollBehavior = options.info?.scrollBehavior ?? "instant";
+    if (scrollToTop && history.scrollRestoration === "auto") {
+        window.scrollTo({
+            top: 0,
+            left: 0,
+            behavior: scrollBehavior,
+        });
+        saveScrollPosition(0, 0);
+    }
+}
+function saveScrollPosition(x, y) {
+    window.history.replaceState({
+        ...window.history.state,
+        scrollX: x,
+        scrollY: y,
+    }, "", window.location.href);
+}
+/**
+ * Initializes client-side navigation for Single Page App (SPA) behavior.
+ *
+ * Intercepts clicks on internal links and fetches page content without full-page reloads.
+ * Returns a handleResponse function to pass to initClient.
+ *
+ * @param opts.scrollToTop - Scroll to top after navigation (default: true)
+ * @param opts.scrollBehavior - How to scroll: 'instant', 'smooth', or 'auto' (default: 'instant')
+ * @param opts.onNavigate - Callback executed after history push but before RSC fetch
+ *
+ * @example
+ * // Basic usage
+ * import { initClient, initClientNavigation } from "rwsdk/client";
+ *
+ * const { handleResponse } = initClientNavigation();
+ * initClient({ handleResponse });
+ *
+ * @example
+ * // With custom scroll behavior
+ * const { handleResponse } = initClientNavigation({
+ *   scrollBehavior: "smooth",
+ *   scrollToTop: true,
+ * });
+ * initClient({ handleResponse });
+ *
+ * @example
+ * // Preserve scroll position (e.g., for infinite scroll)
+ * const { handleResponse } = initClientNavigation({
+ *   scrollToTop: false,
+ * });
+ * initClient({ handleResponse });
+ *
+ * @example
+ * // With navigation callback
+ * const { handleResponse } = initClientNavigation({
+ *   onNavigate: () => {
+ *     console.log("Navigating to:", window.location.href);
+ *   },
+ * });
+ * initClient({ handleResponse });
+ */
 export function initClientNavigation(opts = {}) {
-    const options = {
-        onNavigate: async function onNavigate() {
-            // @ts-expect-error
-            await globalThis.__rsc_callServer();
-        },
-        scrollToTop: true,
-        scrollBehavior: "instant",
-        ...opts,
-    };
+    IS_CLIENT_NAVIGATION = true;
     history.scrollRestoration = "auto";
     document.addEventListener("click", async function handleClickEvent(event) {
-        // Prevent default navigation
         if (!validateClickEvent(event, event.target)) {
             return;
         }
@@ -57,28 +116,18 @@ export function initClientNavigation(opts = {}) {
         const el = event.target;
         const a = el.closest("a");
         const href = a?.getAttribute("href");
-        saveScrollPosition(window.scrollX, window.scrollY);
-        window.history.pushState({ path: href }, "", window.location.origin + href);
-        await options.onNavigate();
-        if (options.scrollToTop && history.scrollRestoration === "auto") {
-            window.scrollTo({
-                top: 0,
-                left: 0,
-                behavior: options.scrollBehavior,
-            });
-            saveScrollPosition(0, 0);
-        }
-        history.scrollRestoration = "auto";
+        navigate(href);
     }, true);
     window.addEventListener("popstate", async function handlePopState() {
-        saveScrollPosition(window.scrollX, window.scrollY);
-        await options.onNavigate();
+        // @ts-expect-error
+        await globalThis.__rsc_callServer();
     });
     // Return a handleResponse function for use with initClient
     return {
         handleResponse: function handleResponse(response) {
             if (!response.ok) {
                 // Redirect to the current page (window.location) to show the error
+                // This means the page that produced the error is called twice.
                 window.location.href = window.location.href;
                 return false;
             }

package/dist/runtime/entries/clientSSR.d.ts

@@ -1,2 +1,3 @@
 import "./types/ssr";
 export * from "../lib/streams/consumeEventStream";
+export declare const navigate: () => void;

package/dist/runtime/entries/clientSSR.js

@@ -1,2 +1,5 @@
 import "./types/ssr";
 export * from "../lib/streams/consumeEventStream";
+export const navigate = () => {
+    /* stub */
+};

package/dist/runtime/entries/no-react-server-ssr-bridge.js

@@ -0,0 +1,2 @@
+"use strict";
+throw new Error("rwsdk: SSR bridge was resolved with 'react-server' condition. This is a bug - the SSR bridge should be intercepted by the esbuild plugin before reaching package.json exports. Please report this issue.");

package/dist/runtime/entries/router.d.ts

@@ -1,3 +1,4 @@
 import "./types/shared";
 export * from "../lib/links";
 export * from "../lib/router";
+export type { DocumentProps, LayoutProps } from "../lib/types";

package/dist/runtime/entries/routerClient.d.ts

@@ -0,0 +1 @@
+export { defineLinks, linkFor } from "../lib/links.js";

package/dist/runtime/entries/routerClient.js

@@ -0,0 +1 @@
+export { defineLinks, linkFor } from "../lib/links.js";

package/dist/runtime/entries/worker.d.ts

@@ -1,10 +1,12 @@
 import "./types/worker";
 export * from "../error";
+export * from "../lib/types";
 export * from "../lib/utils";
 export * from "../register/worker";
 export * from "../render/renderToStream";
 export * from "../render/renderToString";
 export * from "../requestInfo/types";
+export * from "../requestInfo/utils";
 export * from "../requestInfo/worker";
 export * from "../script";
 export * from "../worker";

package/dist/runtime/entries/worker.js

@@ -1,10 +1,12 @@
 import "./types/worker";
 export * from "../error";
+export * from "../lib/types";
 export * from "../lib/utils";
 export * from "../register/worker";
 export * from "../render/renderToStream";
 export * from "../render/renderToString";
 export * from "../requestInfo/types";
+export * from "../requestInfo/utils";
 export * from "../requestInfo/worker";
 export * from "../script";
 export * from "../worker";

package/dist/runtime/imports/__mocks__/use-client-lookup.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Mock implementation of the virtual:use-client-lookup.js module for tests.
+ * This provides an empty lookup object since tests don't need to actually
+ * load client modules - they use dependency injection for React hooks.
+ */
+export declare const useClientLookup: Record<string, () => Promise<any>>;

package/dist/runtime/imports/__mocks__/use-client-lookup.js

@@ -0,0 +1,6 @@
+/**
+ * Mock implementation of the virtual:use-client-lookup.js module for tests.
+ * This provides an empty lookup object since tests don't need to actually
+ * load client modules - they use dependency injection for React hooks.
+ */
+export const useClientLookup = {};

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

@@ -1,11 +1,11 @@
 import { DurableObject } from "cloudflare:workers";
-import { Kysely, QueryResult } from "kysely";
+import { Kysely, KyselyPlugin, 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);
+    constructor(ctx: DurableObjectState, env: any, migrations: Record<string, any>, migrationTableName?: string, plugins?: KyselyPlugin[]);
     initialize(): Promise<void>;
     kyselyExecuteQuery<R>(compiledQuery: {
         sql: string;

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

@@ -6,14 +6,14 @@ import { createMigrator } from "./index.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") {
+    constructor(ctx, env, migrations, migrationTableName = "__migrations", plugins = [new ParseJSONResultsPlugin()]) {
         super(ctx, env);
         this.initialized = false;
         this.migrations = migrations;
         this.migrationTableName = migrationTableName;
         this.kysely = new Kysely({
             dialect: new DODialect({ ctx }),
-            plugins: [new ParseJSONResultsPlugin()],
+            plugins: plugins,
         });
     }
     async initialize() {

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

@@ -1,3 +1,2 @@
 import { Kysely } from "kysely";
-import { type SqliteDurableObject } from "./index.js";
-export declare function createDb<T>(durableObjectBinding: DurableObjectNamespace<SqliteDurableObject>, name?: string): Kysely<T>;
+export declare function createDb<DatabaseType>(durableObjectBinding: DurableObjectNamespace<any>, name?: string): Kysely<DatabaseType>;

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

@@ -5,6 +5,10 @@ export function createDb(durableObjectBinding, name = "main") {
         dialect: new DOWorkerDialect({
             kyselyExecuteQuery: (...args) => {
                 const durableObjectId = durableObjectBinding.idFromName(name);
+                // context(justinvdm, 2 Oct 2025): First prize would be a type parameter
+                // for the durable object and then use it for `durableObjectBinding`'s
+                // type, rather than casting like this. However, that would prevent
+                // users from being able to do createDb<InferredDbType> then though.
                 const stub = durableObjectBinding.get(durableObjectId);
                 stub.initialize();
                 return stub.kyselyExecuteQuery(...args);

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

@@ -1,8 +1,14 @@
 import { CheckConstraintNode, Expression, ForeignKeyConstraintBuilder, PrimaryKeyConstraintNode, sql, UniqueConstraintNode } from "kysely";
 import { AddColumnOp, AlterColumnOp, AlterOperation, DropColumnOp, ExecutedBuilder, ModifyColumnOp, RenameColumnOp, SqlToTsType } from "../utils";
 import { AlterColumnBuilderCallback } from "./alterColumn";
-import { ColumnDefinitionBuilder } from "./columnDefinition";
+import { ColumnDefinitionBuilder, ColumnDescriptor } from "./columnDefinition";
 type DataTypeExpression = string | typeof sql;
+type InitialDescriptor<TType> = {
+    tsType: TType;
+    isNullable: true;
+    hasDefault: false;
+    isAutoIncrement: false;
+};
 interface CheckConstraintBuilder {
     $call<T>(func: (qb: this) => T): T;
     toOperationNode(): CheckConstraintNode;
@@ -31,14 +37,18 @@ export interface AlterTableBuilder<TName extends string, TOps extends AlterOpera
         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>]>;
+    addColumn<K extends string, T extends DataTypeExpression>(name: K, type: T): AlterTableBuilder<TName, [
+        ...TOps,
+        AddColumnOp<K, T, InitialDescriptor<SqlToTsType<T>>>
+    ]>;
+    addColumn<K extends string, T extends DataTypeExpression, TDescriptor extends ColumnDescriptor>(name: K, type: T, build: (col: ColumnDefinitionBuilder<InitialDescriptor<SqlToTsType<T>>>) => ColumnDefinitionBuilder<TDescriptor>): AlterTableBuilder<TName, [...TOps, AddColumnOp<K, T, TDescriptor>]>;
     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>]>;
+    modifyColumn<K extends string, T extends DataTypeExpression, TDescriptor extends ColumnDescriptor>(column: K, type: T, build?: (col: ColumnDefinitionBuilder<InitialDescriptor<SqlToTsType<T>>>) => ColumnDefinitionBuilder<TDescriptor>): AlterTableBuilder<TName, [...TOps, ModifyColumnOp<K, T, TDescriptor>]>;
     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>;

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

@@ -1,25 +1,39 @@
 import { ColumnDefinitionNode, Expression, sql } 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>;
+type DefaultValueExpression = string | number | boolean | null | ReturnType<typeof sql>;
+export type ColumnDescriptor = {
+    tsType: any;
+    isNullable: boolean;
+    hasDefault: boolean;
+    isAutoIncrement: boolean;
+};
+export interface ColumnDefinitionBuilder<TDescriptor extends ColumnDescriptor> {
+    autoIncrement(): ColumnDefinitionBuilder<{
+        [K in keyof TDescriptor]: K extends "isAutoIncrement" ? true : TDescriptor[K];
+    }>;
+    identity(): ColumnDefinitionBuilder<TDescriptor>;
+    primaryKey(): ColumnDefinitionBuilder<{
+        [K in keyof TDescriptor]: K extends "isNullable" ? false : TDescriptor[K];
+    }>;
+    references(ref: string): ColumnDefinitionBuilder<TDescriptor>;
+    onDelete(onDelete: "no action" | "restrict" | "cascade" | "set null" | "set default"): ColumnDefinitionBuilder<TDescriptor>;
+    onUpdate(onUpdate: "no action" | "restrict" | "cascade" | "set null" | "set default"): ColumnDefinitionBuilder<TDescriptor>;
+    unique(): ColumnDefinitionBuilder<TDescriptor>;
+    notNull(): ColumnDefinitionBuilder<{
+        [K in keyof TDescriptor]: K extends "isNullable" ? false : TDescriptor[K];
+    }>;
+    unsigned(): ColumnDefinitionBuilder<TDescriptor>;
+    defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder<{
+        [K in keyof TDescriptor]: K extends "isNullable" ? false : K extends "hasDefault" ? true : TDescriptor[K];
+    }>;
+    check(expression: Expression<any>): ColumnDefinitionBuilder<TDescriptor>;
+    generatedAlwaysAs(expression: Expression<any>): ColumnDefinitionBuilder<TDescriptor>;
+    generatedAlwaysAsIdentity(): ColumnDefinitionBuilder<TDescriptor>;
+    generatedByDefaultAsIdentity(): ColumnDefinitionBuilder<TDescriptor>;
+    stored(): ColumnDefinitionBuilder<TDescriptor>;
+    modifyFront(modifier: Expression<any>): ColumnDefinitionBuilder<TDescriptor>;
+    nullsNotDistinct(): ColumnDefinitionBuilder<TDescriptor>;
+    ifNotExists(): ColumnDefinitionBuilder<TDescriptor>;
+    modifyEnd(modifier: Expression<any>): ColumnDefinitionBuilder<TDescriptor>;
     $call<T>(func: (qb: this) => T): T;
     toOperationNode(): ColumnDefinitionNode;
 }

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

@@ -1,6 +1,6 @@
 import { CheckConstraintNode, CompiledQuery, CreateTableNode, Expression, ForeignKeyConstraintBuilder, PrimaryKeyConstraintNode, UniqueConstraintNode } from "kysely";
 import { ExecutedBuilder, Prettify, SqlToTsType } from "../utils";
-import { ColumnDefinitionBuilder } from "./columnDefinition";
+import { ColumnDefinitionBuilder, ColumnDescriptor } from "./columnDefinition";
 interface CheckConstraintBuilder {
     $call<T>(func: (qb: this) => T): T;
     toOperationNode(): CheckConstraintNode;
@@ -22,13 +22,20 @@ interface PrimaryKeyConstraintBuilder {
     $call<T>(func: (qb: this) => T): T;
     toOperationNode(): PrimaryKeyConstraintNode;
 }
+type InitialDescriptor<TType> = {
+    tsType: TType;
+    isNullable: true;
+    hasDefault: false;
+    isAutoIncrement: false;
+};
 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>>>>;
+    addColumn<K extends string, T extends string>(name: K, type: T): CreateTableBuilder<TName, Prettify<(TSchema extends Record<string, any> ? TSchema : {}) & Record<K, InitialDescriptor<SqlToTsType<T>>>>>;
+    addColumn<K extends string, T extends string, TDescriptor extends ColumnDescriptor>(name: K, type: T, build: (col: ColumnDefinitionBuilder<InitialDescriptor<SqlToTsType<T>>>) => ColumnDefinitionBuilder<TDescriptor>): CreateTableBuilder<TName, Prettify<(TSchema extends Record<string, any> ? TSchema : {}) & Record<K, TDescriptor>>>;
     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>;

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

@@ -1,9 +1,10 @@
-import { Kysely } from "kysely";
+import { Generated, Kysely } from "kysely";
 import { AlterTableBuilder } from "./builders/alterTable";
 import { CreateTableBuilder } from "./builders/createTable";
 import { DropTableBuilder } from "./builders/dropTable";
 import { SchemaBuilder } from "./builders/schema";
 import { ExecutedBuilder, Prettify, ProcessAlteredTable, UnionToTuple } from "./utils";
+import { ColumnDescriptor } from "./builders/columnDefinition";
 export interface InferenceBuilder {
     schema: SchemaBuilder;
 }
@@ -23,5 +24,18 @@ type ApplyBuilders<TSchema, TBuildersTuple> = TBuildersTuple extends [
     ...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>>;
+type TableToSelectType<TTable> = Prettify<{
+    [K in keyof TTable]: TTable[K] extends ColumnDescriptor ? TTable[K]["isNullable"] extends true ? TTable[K]["tsType"] | null : TTable[K]["tsType"] : TTable[K];
+}>;
+type TableToKyselySchema<TTable> = Prettify<{
+    [K in keyof TTable]: TTable[K] extends ColumnDescriptor ? TTable[K]["hasDefault"] extends true ? Generated<TTable[K]["isNullable"] extends true ? TTable[K]["tsType"] | null : TTable[K]["tsType"]> : TTable[K]["isAutoIncrement"] extends true ? Generated<TTable[K]["tsType"]> : TTable[K]["isNullable"] extends true ? TTable[K]["tsType"] | null : TTable[K]["tsType"] : TTable[K];
+}>;
+type DatabaseWithDescriptors<TMigrations extends Migrations = Migrations> = ProcessMigrations<TMigrations, UnionToTuple<keyof TMigrations>>;
+export type Database<TMigrations extends Migrations = Migrations> = Prettify<{
+    [K in keyof DatabaseWithDescriptors<TMigrations>]: TableToSelectType<DatabaseWithDescriptors<TMigrations>[K]>;
+} & {
+    __kyselySchema: {
+        [K in keyof DatabaseWithDescriptors<TMigrations>]: TableToKyselySchema<DatabaseWithDescriptors<TMigrations>[K]>;
+    };
+}>;
 export {};

package/dist/runtime/lib/db/typeInference/typetests/alterTable.typetest.js

@@ -97,7 +97,7 @@
             },
         },
     };
-    //(_test: Expect<Equal<Actual, Expected>>) => {};
+    //(_test: ExpectDb<Actual, Expected>) => {};
 };
 (_it = "alterTable addUniqueConstraint") => {
     const migrations = {
@@ -123,7 +123,7 @@
             },
         },
     };
-    //(_test: Expect<Equal<Actual, Expected>>) => {};
+    //(_test: ExpectDb<Actual, Expected>) => {};
 };
 (_it = "alterTable drop column") => {
     const migrations = {
@@ -153,7 +153,7 @@
             up: async (db) => [
                 await db.schema
                     .createTable("users")
-                    .addColumn("id", "integer")
+                    .addColumn("id", "integer", (c) => c.primaryKey().autoIncrement())
                     .execute(),
             ],
         },
@@ -242,7 +242,7 @@
                 return [
                     await db.schema
                         .createTable("users")
-                        .addColumn("id", "integer")
+                        .addColumn("id", "integer", (col) => col.notNull())
                         .execute(),
                 ];
             },
@@ -271,7 +271,7 @@
                 return [
                     await db.schema
                         .createTable("users")
-                        .addColumn("id", "integer")
+                        .addColumn("id", "integer", (col) => col.primaryKey().autoIncrement())
                         .execute(),
                 ];
             },
@@ -357,4 +357,79 @@
     };
     (_test) => { };
 };
+(_it = "alterTable addColumn with notNull") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("id", "integer", (col) => col.primaryKey())
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("users")
+                        .addColumn("email", "text", (col) => col.notNull())
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable modifyColumn with notNull") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("products")
+                        .addColumn("price", "real")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("products")
+                        .modifyColumn("price", "real", (col) => col.notNull())
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable modifyColumn nullable to non-nullable") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("orders")
+                        .addColumn("status", "text")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("orders")
+                        .modifyColumn("status", "text", (col) => col.notNull().defaultTo("pending"))
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
 export {};