rwsdk 1.0.0-beta.27-test.20251115092208 → 1.0.0-beta.28

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 | ReturnType<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>;
+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 {};

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

@@ -22,9 +22,11 @@ import { sql } from "kysely";
                     await db.schema
                         .createTable("users")
                         .addColumn("username", "text", (col) => col.notNull())
-                        .addColumn("age", "integer", (col) => col.defaultTo(18))
                         .addColumn("active", "boolean", (col) => col.defaultTo(true))
                         .addColumn("anotherBoolean", "boolean", (col) => col.defaultTo(sql `true`))
+                        .addColumn("email", "text", (col) => col)
+                        .addColumn("favoriteColor", "text", (col) => col.unique())
+                        .addColumn("name", "text", (col) => col.defaultTo("John Doe"))
                         .execute(),
                 ];
             },
@@ -32,3 +34,102 @@ import { sql } from "kysely";
     };
     (_test) => { };
 };
+(_it = "createTable column without callback is nullable") => {
+    const migrations = {
+        "001_init": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("posts")
+                        .addColumn("title", "text")
+                        .addColumn("body", "text")
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "createTable with primaryKey is non-nullable") => {
+    const migrations = {
+        "001_init": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("id", "integer", (col) => col.primaryKey())
+                        .addColumn("email", "text", (col) => col.notNull())
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "createTable with unique but no notNull is nullable") => {
+    const migrations = {
+        "001_init": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("products")
+                        .addColumn("sku", "text", (col) => col.unique())
+                        .addColumn("name", "text", (col) => col)
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_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,9 +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> = {
+export type AddColumnOp<K extends string, T extends DataTypeExpression, TDescriptor extends ColumnDescriptor> = {
     op: "addColumn";
     name: K;
     type: T;
+    descriptor: TDescriptor;
 };
 export type DropColumnOp<K extends string> = {
     op: "dropColumn";
@@ -14,10 +16,11 @@ export type RenameColumnOp<KFrom extends string, KTo extends string> = {
     from: KFrom;
     to: KTo;
 };
-export type ModifyColumnOp<K extends string, T extends DataTypeExpression> = {
+export type ModifyColumnOp<K extends string, T extends DataTypeExpression, TDescriptor extends ColumnDescriptor> = {
     op: "modifyColumn";
     name: K;
     type: T;
+    descriptor: TDescriptor;
 };
 export type Alteration = {
     kind: "setDataType";
@@ -37,7 +40,7 @@ export type AlterColumnOp<K extends string, TAlteration extends Alteration> = {
     name: K;
     alteration: TAlteration;
 };
-export type AlterOperation = AddColumnOp<any, any> | DropColumnOp<any> | RenameColumnOp<any, any> | AlterColumnOp<any, any> | ModifyColumnOp<any, any>;
+export type AlterOperation = AddColumnOp<any, any, any> | DropColumnOp<any> | RenameColumnOp<any, any> | AlterColumnOp<any, any> | ModifyColumnOp<any, any, any>;
 export type SqlToTsType<T extends string | typeof sql> = T extends "text" ? string : T extends "integer" ? number : T extends "blob" ? Uint8Array : T extends "real" ? number : T extends "boolean" ? boolean : T extends typeof sql ? any : never;
 export type Prettify<T> = {
     [K in keyof T]: T[K];
@@ -57,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> ? Prettify<TSchema & {
-    [P in K]: 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> ? Prettify<Omit<TSchema, K> & {
-    [P in K]: 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/dist/runtime/lib/stitchDocumentAndAppStreams.d.ts

@@ -15,4 +15,70 @@
  * @param startMarker The marker in the document to start injecting the app.
  * @param endMarker The marker in the app stream that signals the end of the initial, non-suspended render.
  */
+/**
+ * A utility that orchestrates and interleaves three ReadableStreams to produce a
+ * single, valid HTML response stream. It uses two special markers:
+ *
+ * - `startMarker`: Placed in the `outerHtml` stream (the document shell) to
+ *   designate where the application's content should be injected.
+ * - `endMarker`: Injected into the `innerHtml` stream's RSC payload to signal
+ *   the end of the initial, non-suspended render. This marker is needed for
+ *   non-blocking hydration, as it allows the stitching process to send the
+ *   client `<script>` tags before all suspended content has resolved.
+ *
+ * It manages three main stream readers:
+ *
+ * - `hoistedTagsReader`: Reads from the `hoistedTagsStream`, which contains only
+ *   the hoisted meta tags (e.g., `<title>`, `<meta>`).
+ * - `outerReader`: Reads from the `outerHtml` stream, which is the server-rendered
+ *   document shell (containing `<html>`, `<head>`, etc.).
+ * - `innerReader`: Reads from the `appBodyStream`, which contains the main
+ *   application content, stripped of its hoisted tags.
+ *
+ * The function proceeds through a multi-phase state machine, managed by the
+ * `pump` function, to correctly interleave these streams.
+ *
+ * The state machine moves through the following phases:
+ *
+ * 1. `read-hoisted`:
+ *    - **Goal:** Buffer all hoisted tags from the `hoistedTagsStream`.
+ *    - **Action:** Reads from `hoistedTagsReader` and appends all content into
+ *      the `hoistedTagsBuffer`. Does not enqueue anything yet.
+ *    - **Transition:** Moves to `outer-head` when the stream is exhausted.
+ *
+ * 2. `outer-head`:
+ *    - **Goal:** Stream the document up to the closing `</head>` tag, inject the
+ *      hoisted tags, and then continue until the app `startMarker`.
+ *    - **Action:** Reads from `outerReader`. When it finds `</head>`, it enqueues
+ *      the content before it, then enqueues the `hoistedTagsBuffer`, and finally
+ *      enqueues the `</head>` tag itself. It then continues reading from
+ *      `outerReader` until it finds the `startMarker`.
+ *    - **Transition:** Moves to `inner-shell` after finding and discarding the
+ *      `startMarker`.
+ *
+ * 3. `inner-shell`:
+ *    - **Goal:** Stream the initial, non-suspended part of the application.
+ *    - **Action:** Switches to `innerReader`. It enqueues chunks until it finds
+ *      the `endMarker`. Any content after the marker is stored in
+ *      `innerSuspendedRemains`.
+ *    - **Transition:** Moves to `outer-tail` after finding the `endMarker`.
+ *
+ * 4. `outer-tail`:
+ *    - **Goal:** Stream the rest of the document's `<body>`, including client
+ *      `<script>` tags.
+ *    - **Action:** Switches back to `outerReader` and enqueues chunks until it
+ *      finds the `</body>` tag.
+ *    - **Transition:** Moves to `inner-suspended` after finding `</body>`.
+ *
+ * 5. `inner-suspended`:
+ *    - **Goal:** Stream any suspended content from the React app.
+ *    - **Action:** First enqueues any content from `innerSuspendedRemains`, then
+ *      continues reading from `innerReader` until the stream is exhausted.
+ *    - **Transition:** Moves to `outer-end` when the stream is exhausted.
+ *
+ * 6. `outer-end`:
+ *    - **Goal:** Finish the document.
+ *    - **Action:** Switches back to `outerReader` for the last time to send the
+ *      closing `</body>` and `</html>` tags.
+ */
 export declare function stitchDocumentAndAppStreams(outerHtml: ReadableStream<Uint8Array>, innerHtml: ReadableStream<Uint8Array>, startMarker: string, endMarker: string): ReadableStream<Uint8Array>;