rwsdk 1.0.0-beta.27-test.20251111115809 → 1.0.0-beta.27-test.20251112194755

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, TNullable extends boolean = true>(name: K, type: T, build?: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>, TNullable>): AlterTableBuilder<TName, [...TOps, AddColumnOp<K, T, TNullable>]>;
+    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, TNullable extends boolean = true>(column: K, type: T, build?: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>, TNullable>): AlterTableBuilder<TName, [...TOps, ModifyColumnOp<K, T, TNullable>]>;
+    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 | ReturnType<typeof sql>;
-export interface ColumnDefinitionBuilder<TType, TNullable extends boolean = true> {
-    autoIncrement(): ColumnDefinitionBuilder<TType, TNullable>;
-    identity(): ColumnDefinitionBuilder<TType, TNullable>;
-    primaryKey(): ColumnDefinitionBuilder<TType, false>;
-    references(ref: string): ColumnDefinitionBuilder<TType, TNullable>;
-    onDelete(onDelete: "no action" | "restrict" | "cascade" | "set null" | "set default"): ColumnDefinitionBuilder<TType, TNullable>;
-    onUpdate(onUpdate: "no action" | "restrict" | "cascade" | "set null" | "set default"): ColumnDefinitionBuilder<TType, TNullable>;
-    unique(): ColumnDefinitionBuilder<TType, TNullable>;
-    notNull(): ColumnDefinitionBuilder<TType, false>;
-    unsigned(): ColumnDefinitionBuilder<TType, TNullable>;
-    defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder<TType, false>;
-    check(expression: Expression<any>): ColumnDefinitionBuilder<TType, TNullable>;
-    generatedAlwaysAs(expression: Expression<any>): ColumnDefinitionBuilder<TType, TNullable>;
-    generatedAlwaysAsIdentity(): ColumnDefinitionBuilder<TType, TNullable>;
-    generatedByDefaultAsIdentity(): ColumnDefinitionBuilder<TType, TNullable>;
-    stored(): ColumnDefinitionBuilder<TType, TNullable>;
-    modifyFront(modifier: Expression<any>): ColumnDefinitionBuilder<TType, TNullable>;
-    nullsNotDistinct(): ColumnDefinitionBuilder<TType, TNullable>;
-    ifNotExists(): ColumnDefinitionBuilder<TType, TNullable>;
-    modifyEnd(modifier: Expression<any>): ColumnDefinitionBuilder<TType, TNullable>;
+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,14 +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): CreateTableBuilder<TName, Prettify<(TSchema extends Record<string, any> ? TSchema : {}) & Record<K, SqlToTsType<T> | null>>>;
-    addColumn<K extends string, T extends string, TNullable extends boolean>(name: K, type: T, build: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>, TNullable>): CreateTableBuilder<TName, Prettify<(TSchema extends Record<string, any> ? TSchema : {}) & Record<K, TNullable extends true ? SqlToTsType<T> | null : 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 = {

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

@@ -82,3 +82,54 @@ import { sql } from "kysely";
     };
     (_test) => { };
 };
+(_it = "defaultTo makes columns non-nullable in Database type") => {
+    const migrations = {
+        "001_init": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("status", "text", (col) => col.defaultTo("active"))
+                        .addColumn("count", "integer", (col) => col.defaultTo(0))
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+// --- Insert/Update Type Tests ---
+(_it = "makes autoIncrement columns optional on insert") => {
+    const migrations = {
+        "001_init": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("id", "integer", (col) => col.primaryKey().autoIncrement())
+                        .addColumn("username", "text", (col) => col.notNull())
+                        .execute(),
+                ];
+            },
+        },
+    };
+    const db = {};
+    db.insertInto("users").values({ username: "test" });
+};
+(_it = "makes defaultTo columns optional on insert") => {
+    const migrations = {
+        "001_init": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("username", "text", (col) => col.notNull())
+                        .addColumn("status", "text", (col) => col.notNull().defaultTo("active"))
+                        .execute(),
+                ];
+            },
+        },
+    };
+    const db = {};
+    db.insertInto("users").values({ username: "test" });
+};

package/dist/runtime/lib/db/typeInference/typetests/testUtils.d.ts

@@ -1,2 +1,3 @@
 export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
 export type Expect<T extends true> = T;
+export type OmitInternals<T> = Omit<T, "__kyselySchema">;

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

@@ -1,10 +1,11 @@
 import { sql } from "kysely";
+import { ColumnDescriptor } from "./builders/columnDefinition";
 type DataTypeExpression = string | typeof sql;
-export type AddColumnOp<K extends string, T extends DataTypeExpression, TNullable extends boolean = true> = {
+export type AddColumnOp<K extends string, T extends DataTypeExpression, TDescriptor extends ColumnDescriptor> = {
     op: "addColumn";
     name: K;
     type: T;
-    nullable: TNullable;
+    descriptor: TDescriptor;
 };
 export type DropColumnOp<K extends string> = {
     op: "dropColumn";
@@ -15,11 +16,11 @@ export type RenameColumnOp<KFrom extends string, KTo extends string> = {
     from: KFrom;
     to: KTo;
 };
-export type ModifyColumnOp<K extends string, T extends DataTypeExpression, TNullable extends boolean = true> = {
+export type ModifyColumnOp<K extends string, T extends DataTypeExpression, TDescriptor extends ColumnDescriptor> = {
     op: "modifyColumn";
     name: K;
     type: T;
-    nullable: TNullable;
+    descriptor: TDescriptor;
 };
 export type Alteration = {
     kind: "setDataType";
@@ -59,17 +60,64 @@ export type Cast<A, B> = A extends B ? A : B;
 /**
  * Applies a single alteration operation to a schema.
  */
-type ApplyOp<TSchema, THeadOp> = THeadOp extends AddColumnOp<infer K, infer T, infer TNullable> ? Prettify<TSchema & {
-    [P in K]: TNullable extends true ? SqlToTsType<T> | null : SqlToTsType<T>;
+type ApplyOp<TSchema, THeadOp> = THeadOp extends AddColumnOp<infer K, any, infer TDescriptor> ? Prettify<TSchema & {
+    [P in K]: TDescriptor;
 }> : THeadOp extends DropColumnOp<infer K> ? Omit<TSchema, K> : THeadOp extends RenameColumnOp<infer KFrom, infer KTo> ? KFrom extends keyof TSchema ? Prettify<Omit<TSchema, KFrom> & {
     [P in KTo]: TSchema[KFrom];
-}> : TSchema : THeadOp extends AlterColumnOp<infer K, infer TAlt> ? TAlt extends {
+}> : TSchema : THeadOp extends AlterColumnOp<infer K, infer TAlt> ? K extends keyof TSchema ? TAlt extends {
     kind: "setDataType";
     dataType: infer DT extends string;
 } ? Prettify<Omit<TSchema, K> & {
-    [P in K]: SqlToTsType<DT>;
-}> : TSchema : THeadOp extends ModifyColumnOp<infer K, infer T, infer TNullable> ? Prettify<Omit<TSchema, K> & {
-    [P in K]: TNullable extends true ? SqlToTsType<T> | null : SqlToTsType<T>;
+    [P in K]: {
+        tsType: SqlToTsType<DT>;
+        isNullable: TSchema[K] extends {
+            isNullable: infer N;
+        } ? N : true;
+        hasDefault: TSchema[K] extends {
+            hasDefault: infer D;
+        } ? D : false;
+        isAutoIncrement: TSchema[K] extends {
+            isAutoIncrement: infer A;
+        } ? A : false;
+    };
+}> : TAlt extends {
+    kind: "setDefault";
+} ? Prettify<Omit<TSchema, K> & {
+    [P in K]: TSchema[K] extends ColumnDescriptor ? {
+        tsType: TSchema[K]["tsType"];
+        isNullable: false;
+        hasDefault: true;
+        isAutoIncrement: TSchema[K]["isAutoIncrement"];
+    } : TSchema[K];
+}> : TAlt extends {
+    kind: "dropDefault";
+} ? Prettify<Omit<TSchema, K> & {
+    [P in K]: TSchema[K] extends ColumnDescriptor ? {
+        tsType: TSchema[K]["tsType"];
+        isNullable: TSchema[K]["isNullable"];
+        hasDefault: false;
+        isAutoIncrement: TSchema[K]["isAutoIncrement"];
+    } : TSchema[K];
+}> : TAlt extends {
+    kind: "setNotNull";
+} ? Prettify<Omit<TSchema, K> & {
+    [P in K]: TSchema[K] extends ColumnDescriptor ? {
+        tsType: TSchema[K]["tsType"];
+        isNullable: false;
+        hasDefault: TSchema[K]["hasDefault"];
+        isAutoIncrement: TSchema[K]["isAutoIncrement"];
+    } : TSchema[K];
+}> : TAlt extends {
+    kind: "dropNotNull";
+} ? Prettify<Omit<TSchema, K> & {
+    [P in K]: TSchema[K] extends ColumnDescriptor ? {
+        tsType: TSchema[K]["tsType"];
+        isNullable: true;
+        hasDefault: TSchema[K]["hasDefault"];
+        isAutoIncrement: TSchema[K]["isAutoIncrement"];
+    } : TSchema[K];
+}> : TSchema : TSchema : THeadOp extends ModifyColumnOp<infer K, any, infer TDescriptor> ? Prettify<Omit<TSchema, K> & {
+    [P in K]: TDescriptor;
 }> : TSchema;
 /**
  * Recursively processes a list of alteration operations (AST)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.0.0-beta.27-test.20251111115809",
+  "version": "1.0.0-beta.27-test.20251112194755",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {