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

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

@@ -1,3 +1,4 @@
+import { sql } from "kysely";
 (_it = "createTable") => {
     const migrations = {
         "001_init": {
@@ -21,8 +22,11 @@
                     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(),
                 ];
             },
@@ -30,4 +34,102 @@
     };
     (_test) => { };
 };
-export {};
+(_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/links.d.ts

@@ -1,14 +1,28 @@
-type ParseRoute<T extends string> = T extends `${infer Start}:${infer Param}/${infer Rest}` ? {
+import type { RouteDefinition, RouteMiddleware } from "./router";
+type PathParams<Path extends string> = Path extends `${string}:${infer Param}/${infer Rest}` ? {
     [K in Param]: string;
-} & ParseRoute<Rest> : T extends `${infer Start}:${infer Param}` ? {
+} & PathParams<Rest> : Path extends `${string}:${infer Param}` ? {
     [K in Param]: string;
-} : T extends `${infer Start}*${infer Rest}` ? {
+} : Path extends `${string}*${infer Rest}` ? {
     $0: string;
-} & ParseRoute<Rest> : T extends `${infer Start}*` ? {
+} & PathParams<Rest> : Path extends `${string}*` ? {
     $0: string;
 } : {};
-type LinkFunction<T extends readonly string[]> = {
-    <Path extends T[number]>(path: Path, params?: ParseRoute<Path> extends Record<string, never> ? undefined : ParseRoute<Path>): string;
+type ParamsForPath<Path extends string> = PathParams<Path> extends Record<string, never> ? undefined : PathParams<Path>;
+export type LinkFunction<Paths extends string> = {
+    <Path extends Paths>(path: Path, params?: ParamsForPath<Path>): string;
 };
-export declare function defineLinks<const T extends readonly string[]>(routes: T): LinkFunction<T>;
+type RoutePaths<Value> = Value extends RouteDefinition<infer Path, any> ? Path : Value extends readonly (infer Item)[] ? RouteArrayPaths<Value> : Value extends RouteMiddleware<any> ? never : never;
+type RouteArrayPaths<Routes extends readonly any[]> = number extends Routes["length"] ? RoutePaths<Routes[number]> : Routes extends readonly [infer Head, ...infer Tail] ? RoutePaths<Head> | RouteArrayPaths<Tail> : never;
+type AppRoutes<App> = App extends {
+    __rwRoutes: infer Routes;
+} ? Routes : never;
+export type AppRoutePaths<App> = RoutePaths<AppRoutes<App>>;
+export type AppLink<App> = LinkFunction<AppRoutePaths<App>>;
+export declare function linkFor<App>(): AppLink<App>;
+export declare function createLinks<App>(_app?: App): AppLink<App>;
+export declare function defineLinks<App extends {
+    __rwRoutes: any;
+}>(): AppLink<App>;
+export declare function defineLinks<const T extends readonly string[]>(routes: T): LinkFunction<T[number]>;
 export {};

package/dist/runtime/lib/links.js

@@ -1,38 +1,96 @@
+export function linkFor() {
+    return createLinkFunction();
+}
+export function createLinks(_app) {
+    return linkFor();
+}
+// Implementation
 export function defineLinks(routes) {
-    // Validate routes at runtime
+    // If no routes provided, this is the app type overload
+    // At runtime, we can't distinguish, but the type system ensures
+    // this only happens when called as defineLinks<App>()
+    // We delegate to linkFor which handles app types correctly
+    if (routes === undefined) {
+        // This branch is only reachable when called as defineLinks<App>()
+        // The return type is AppLink<App> due to the overload
+        // We use linkFor internally which doesn't need runtime route validation
+        return linkFor();
+    }
+    // Original implementation for route arrays
     routes.forEach((route) => {
         if (typeof route !== "string") {
             throw new Error(`Invalid route: ${route}. Routes must be strings.`);
         }
     });
-    return (path, params) => {
+    const link = createLinkFunction();
+    return ((path, params) => {
         if (!routes.includes(path)) {
             throw new Error(`Invalid route: ${path}`);
         }
-        if (!params)
+        return link(path, params);
+    });
+}
+const TOKEN_REGEX = /:([a-zA-Z0-9_]+)|\*/g;
+function createLinkFunction() {
+    return ((path, params) => {
+        const expectsParams = hasRouteParameters(path);
+        if (!params || Object.keys(params).length === 0) {
+            if (expectsParams) {
+                throw new Error(`Route ${path} requires an object of parameters`);
+            }
             return path;
-        let result = path;
-        // Replace named parameters
-        for (const [key, value] of Object.entries(params)) {
-            if (key.startsWith("$")) {
-                // Replace each star with its corresponding $ parameter
-                const starIndex = parseInt(key.slice(1));
-                const stars = result.match(/\*/g) || [];
-                if (starIndex >= stars.length) {
-                    throw new Error(`Parameter ${key} has no corresponding * in route`);
-                }
-                // Replace the nth star with the value
-                let count = 0;
-                result = result.replace(/\*/g, (match) => count++ === starIndex ? value : match);
+        }
+        return interpolate(path, params);
+    });
+}
+function hasRouteParameters(path) {
+    TOKEN_REGEX.lastIndex = 0;
+    const result = TOKEN_REGEX.test(path);
+    TOKEN_REGEX.lastIndex = 0;
+    return result;
+}
+function interpolate(template, params) {
+    let result = "";
+    let lastIndex = 0;
+    let wildcardIndex = 0;
+    const consumed = new Set();
+    TOKEN_REGEX.lastIndex = 0;
+    let match;
+    while ((match = TOKEN_REGEX.exec(template)) !== null) {
+        result += template.slice(lastIndex, match.index);
+        if (match[1]) {
+            const name = match[1];
+            const value = params[name];
+            if (value === undefined) {
+                throw new Error(`Missing parameter "${name}" for route ${template}`);
             }
-            else {
-                // Handle named parameters
-                if (typeof value !== "string") {
-                    throw new Error(`Parameter ${key} must be a string`);
-                }
-                result = result.replace(`:${key}`, value);
+            result += encodeURIComponent(value);
+            consumed.add(name);
+        }
+        else {
+            const key = `$${wildcardIndex}`;
+            const value = params[key];
+            if (value === undefined) {
+                throw new Error(`Missing parameter "${key}" for route ${template}`);
             }
+            result += encodeWildcardValue(value);
+            consumed.add(key);
+            wildcardIndex += 1;
+        }
+        lastIndex = TOKEN_REGEX.lastIndex;
+    }
+    result += template.slice(lastIndex);
+    for (const key of Object.keys(params)) {
+        if (!consumed.has(key)) {
+            throw new Error(`Parameter "${key}" is not used by route ${template}`);
         }
-        return result;
-    };
+    }
+    TOKEN_REGEX.lastIndex = 0;
+    return result;
+}
+function encodeWildcardValue(value) {
+    return value
+        .split("/")
+        .map((segment) => encodeURIComponent(segment))
+        .join("/");
 }

package/dist/runtime/lib/links.test.js

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import { defineLinks } from "./links";
+const link = defineLinks(["/", "/users/:id", "/files/*"]);
+describe("link helpers", () => {
+    it("returns static routes without parameters", () => {
+        expect(link("/")).toBe("/");
+    });
+    it("replaces named parameters with encoded values", () => {
+        expect(link("/users/:id", { id: "user id" })).toBe("/users/user%20id");
+    });
+    it("replaces wildcard parameters preserving path segments", () => {
+        expect(link("/files/*", { $0: "docs/Guide Document.md" })).toBe("/files/docs/Guide%20Document.md");
+    });
+    it("throws when parameters are missing", () => {
+        expect(() => link("/users/:id")).toThrowError(/requires an object of parameters/i);
+    });
+    it("throws when extra parameters are supplied", () => {
+        expect(() => link("/users/:id", { id: "123", extra: "value" })).toThrowError(/is not used by route/i);
+    });
+});

package/dist/runtime/lib/manifest.d.ts

@@ -8,4 +8,4 @@ export interface ManifestChunk {
     css?: string[];
     assets?: string[];
 }
-export declare const getManifest: () => Promise<Manifest>;
+export declare function getManifest(): Promise<Manifest>;

package/dist/runtime/lib/manifest.js

@@ -1,14 +1,17 @@
 let manifest;
-export const getManifest = async () => {
+export async function getManifest() {
     if (manifest) {
         return manifest;
     }
     if (import.meta.env.VITE_IS_DEV_SERVER) {
+        // In dev, there's no manifest, so we can use an empty object.
         manifest = {};
     }
     else {
-        const { default: prodManifest } = await import("virtual:rwsdk:manifest.js");
-        manifest = prodManifest;
+        // context(justinvdm, 2 Oct 2025): In production, the manifest is a
+        // placeholder string that will be replaced by the linker plugin with the
+        // actual manifest JSON object.
+        manifest = "__RWSDK_MANIFEST_PLACEHOLDER__";
     }
     return manifest;
-};
+}

package/dist/runtime/lib/realtime/client.js

@@ -1,7 +1,13 @@
-import { createFromReadableStream } from "react-server-dom-webpack/client.browser";
+// context(justinvdm, 14 Aug 2025): `react-server-dom-webpack` uses this globa ___webpack_require__ global,
+// so we need to import our client entry point (which sets it), before importing
+// prettier-ignore
 import { initClient } from "../../client/client";
-import { packMessage, unpackMessage, } from "./protocol";
+// prettier-ignore
+import { createFromReadableStream } from "react-server-dom-webpack/client.browser";
+// prettier-ignore
 import { MESSAGE_TYPE } from "./shared";
+// prettier-ignore
+import { packMessage, unpackMessage, } from "./protocol";
 const DEFAULT_KEY = "default";
 export const initRealtimeClient = ({ key = DEFAULT_KEY, handleResponse, } = {}) => {
     const transport = realtimeTransport({ key, handleResponse });

package/dist/runtime/lib/realtime/worker.d.ts

@@ -1,3 +1,3 @@
 import type { RealtimeDurableObject } from "./durableObject";
 export { renderRealtimeClients } from "./renderRealtimeClients";
-export declare const realtimeRoute: (getDurableObjectNamespace: (env: Cloudflare.Env) => DurableObjectNamespace<RealtimeDurableObject>) => import("../router").RouteDefinition<import("../../worker").RequestInfo<any, import("../../worker").DefaultAppContext>>;
+export declare const realtimeRoute: (getDurableObjectNamespace: (env: Cloudflare.Env) => DurableObjectNamespace<RealtimeDurableObject>) => import("../router").RouteDefinition<"/__realtime", import("../../worker").RequestInfo<any, import("../../worker").DefaultAppContext>>;