rwsdk 0.1.0 → 0.1.2-test.20250626055636

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

@@ -6,7 +6,7 @@ export declare class SqliteDurableObject<T = any> extends DurableObject {
     private initialized;
     private migrationTableName;
     constructor(ctx: DurableObjectState, env: any, migrations: Record<string, any>, migrationTableName?: string);
-    private initialize;
+    initialize(): Promise<void>;
     kyselyExecuteQuery<R>(compiledQuery: {
         sql: string;
         parameters: readonly unknown[];

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

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

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

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

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

@@ -0,0 +1,12 @@
+export interface AlterColumnBuilder {
+    setDataType<T extends string>(dataType: T): AlteredColumnBuilder<"setDataType", T>;
+    setDefault<T>(value: T): AlteredColumnBuilder<"setDefault", T>;
+    dropDefault(): AlteredColumnBuilder<"dropDefault", true>;
+    setNotNull(): AlteredColumnBuilder<"setNotNull", true>;
+    dropNotNull(): AlteredColumnBuilder<"dropNotNull", true>;
+}
+export interface AlteredColumnBuilder<Kind extends string, Value> {
+    readonly kind: Kind;
+    readonly value: Value;
+}
+export type AlterColumnBuilderCallback = (builder: AlterColumnBuilder) => AlteredColumnBuilder<any, any>;

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

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

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

@@ -0,0 +1,21 @@
+import { SqlToTsType, ExecutedBuilder, Prettify } from "../utils";
+import { ColumnDefinitionBuilder } from "./columnDefinition";
+import { AlterColumnBuilderCallback } from "./alterColumn";
+export interface AlterTableBuilder<TName extends string, TSchema extends Record<string, any> = {}> {
+    readonly __tableName: TName;
+    readonly __addedColumns: TSchema;
+    renameTo<TNewName extends string>(newTableName: TNewName): AlterTableBuilder<TNewName, TSchema>;
+    setSchema(newSchema: string): AlterTableBuilder<TName, TSchema>;
+    addColumn<K extends string, T extends string>(name: K, type: T, build?: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>>): AlterTableBuilder<TName, Prettify<TSchema & Record<K, SqlToTsType<T>>>>;
+    dropColumn<K extends string>(name: K): AlterTableBuilder<TName, Prettify<TSchema & {
+        [P in K]: never;
+    }>>;
+    renameColumn<KFrom extends string, KTo extends string>(from: KFrom, to: KTo): AlterTableBuilder<TName, Prettify<TSchema & {
+        [P in KFrom]: never;
+    } & {
+        [P in KTo]: any;
+    }>>;
+    alterColumn<K extends string>(column: K, alteration: AlterColumnBuilderCallback): AlterTableBuilder<TName, TSchema>;
+    modifyColumn<K extends string, T extends string>(column: K, type: T, build?: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>>): AlterTableBuilder<TName, Prettify<TSchema & Record<K, SqlToTsType<T>>>>;
+    execute(): ExecutedBuilder<this>;
+}

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

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

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

@@ -0,0 +1,9 @@
+export interface ColumnDefinitionBuilder<T = any> {
+    primaryKey(): ColumnDefinitionBuilder<T>;
+    notNull(): ColumnDefinitionBuilder<T>;
+    unique(): ColumnDefinitionBuilder<T>;
+    defaultTo<V extends T>(value: V): ColumnDefinitionBuilder<T>;
+    references(ref: string): ColumnDefinitionBuilder<T>;
+    onDelete(action: "cascade" | "restrict" | "set null"): ColumnDefinitionBuilder<T>;
+    unsigned(): ColumnDefinitionBuilder<T>;
+}

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

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

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

@@ -0,0 +1,14 @@
+import { SqlToTsType, ExecutedBuilder, Prettify } from "../utils";
+import { ColumnDefinitionBuilder } from "./columnDefinition";
+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 & Record<K, SqlToTsType<T>>>>;
+    modifyFront(modifier: string): CreateTableBuilder<TName, TSchema>;
+    modifyEnd(modifier: string): CreateTableBuilder<TName, TSchema>;
+    as(expression: string): CreateTableBuilder<TName, TSchema>;
+    execute(): ExecutedBuilder<this>;
+}

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

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

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

@@ -0,0 +1,13 @@
+import { ExecutedBuilder } from "../utils";
+export interface CreateViewBuilder<TName extends string, TSchema extends Record<string, any> = {}, TColumns extends string[] = []> {
+    readonly __viewName: TName;
+    readonly __schema: TSchema;
+    readonly __columns: TColumns;
+    withSchema<S extends Record<string, any>>(): CreateViewBuilder<TName, S, TColumns>;
+    temporary(): CreateViewBuilder<TName, TSchema, TColumns>;
+    orReplace(): CreateViewBuilder<TName, TSchema, TColumns>;
+    ifNotExists(): CreateViewBuilder<TName, TSchema, TColumns>;
+    columns<C extends string[]>(columns: C): CreateViewBuilder<TName, TSchema, C>;
+    as<E extends string>(expression: E): CreateViewBuilder<TName, TSchema, TColumns>;
+    execute(): ExecutedBuilder<this>;
+}

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

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

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

@@ -0,0 +1,7 @@
+import { ExecutedBuilder } from "../utils";
+export interface DropTableBuilder<TName extends string> {
+    readonly __tableName: TName;
+    ifExists(): DropTableBuilder<TName>;
+    cascade(): DropTableBuilder<TName>;
+    execute(): ExecutedBuilder<this>;
+}

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

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

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

@@ -0,0 +1,7 @@
+import { ExecutedBuilder } from "../utils";
+export interface DropViewBuilder<TName extends string> {
+    readonly __viewName: TName;
+    ifExists(): DropViewBuilder<TName>;
+    cascade(): DropViewBuilder<TName>;
+    execute(): ExecutedBuilder<this>;
+}

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

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

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

@@ -0,0 +1,12 @@
+import { TableBuilder } from "./table";
+import { AlterTableBuilder } from "./alterTable";
+import { DropTableBuilder } from "./dropTable";
+import { CreateViewBuilder } from "./createView";
+import { DropViewBuilder } from "./dropView";
+export interface SchemaBuilder {
+    createTable<TName extends string>(name: TName): TableBuilder<TName, {}>;
+    alterTable<TName extends string>(name: TName): AlterTableBuilder<TName, {}>;
+    dropTable<TName extends string>(name: TName): DropTableBuilder<TName>;
+    createView<TName extends string>(name: TName): CreateViewBuilder<TName, {}>;
+    dropView<TName extends string>(name: TName): DropViewBuilder<TName>;
+}

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

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

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

@@ -0,0 +1,10 @@
+import { SqlToTsType, ExecutedBuilder, Prettify } from "../utils";
+import { ColumnDefinitionBuilder } from "./columnDefinition";
+export interface TableBuilder<TName extends string, TSchema extends Record<string, any> = {}> {
+    readonly __tableName: TName;
+    readonly __schema: TSchema;
+    addColumn<K extends string, T extends string>(name: K, type: T, build?: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>>): TableBuilder<TName, Prettify<TSchema & Record<K, SqlToTsType<T>>>>;
+    temporary(): this;
+    ifNotExists(): this;
+    execute(): ExecutedBuilder<this>;
+}

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

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

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

@@ -0,0 +1,38 @@
+import { Kysely } from "kysely";
+import { ExecutedBuilder, Prettify, MergeSchemas, OmitNever, UnionToIntersection } from "./utils";
+import { TableBuilder } from "./builders/table";
+import { CreateViewBuilder } from "./builders/createView.js";
+import { AlterTableBuilder } from "./builders/alterTable.js";
+import { DropTableBuilder } from "./builders/dropTable.js";
+import { DropViewBuilder } from "./builders/dropView.js";
+import { SchemaBuilder } from "./builders/schema";
+export interface InferenceBuilder {
+    schema: SchemaBuilder;
+}
+export type MigrationBuilder = InferenceBuilder & Kysely<any>;
+export interface Migration<TUpReturn = unknown> {
+    up(db: MigrationBuilder): TUpReturn;
+    down?(db: Kysely<any>): any;
+}
+export type Migrations = Record<string, Migration>;
+type GetBuilder<T> = T extends ExecutedBuilder<infer B> ? B : never;
+type BuildersFromMigration<TMigration extends Migration> = TMigration extends Migration<infer TUpReturn> ? Awaited<TUpReturn> extends Array<infer Item> ? GetBuilder<Item> : GetBuilder<Awaited<TUpReturn>> : never;
+type AllBuilders<TMigrations extends Migrations> = BuildersFromMigration<TMigrations[keyof TMigrations]>;
+type CreatedTables<TMigrations extends Migrations> = UnionToIntersection<ExtractTableSchema<Extract<AllBuilders<TMigrations>, TableBuilder<any, any>>>>;
+type CreatedViews<TMigrations extends Migrations> = UnionToIntersection<ExtractViewSchema<Extract<AllBuilders<TMigrations>, CreateViewBuilder<any, any>>>>;
+type AlteredTables<TMigrations extends Migrations> = UnionToIntersection<ExtractAlterSchema<Extract<AllBuilders<TMigrations>, AlterTableBuilder<any, any>>>>;
+type DroppedTableNames<TMigrations extends Migrations> = ExtractDroppedTableName<Extract<AllBuilders<TMigrations>, DropTableBuilder<any>>>;
+type DroppedViewNames<TMigrations extends Migrations> = ExtractDroppedViewName<Extract<AllBuilders<TMigrations>, DropViewBuilder<any>>>;
+type AllCreated<TMigrations extends Migrations> = MergeSchemas<CreatedTables<TMigrations>, CreatedViews<TMigrations>>;
+type MergedSchemaBeforeDrop<TMigrations extends Migrations> = MergeSchemas<AllCreated<TMigrations>, AlteredTables<TMigrations>>;
+type CleanedSchema<T> = {
+    [K in keyof T]: OmitNever<T[K]>;
+};
+type InferredDatabase<TMigrations extends Migrations> = Omit<Omit<CleanedSchema<MergedSchemaBeforeDrop<TMigrations>>, DroppedTableNames<TMigrations>>, DroppedViewNames<TMigrations>>;
+export type Database<TMigrations extends Migrations = Migrations> = Prettify<InferredDatabase<TMigrations>>;
+export type ExtractTableSchema<T> = T extends TableBuilder<infer TName, infer TSchema> ? Record<TName, TSchema> : never;
+export type ExtractViewSchema<T> = T extends CreateViewBuilder<infer TName, infer TSchema> ? Record<TName, TSchema> : never;
+export type ExtractAlterSchema<T> = T extends AlterTableBuilder<infer TName, infer TSchema> ? Record<TName, TSchema> : never;
+export type ExtractDroppedTableName<T> = T extends DropTableBuilder<infer TName> ? TName : never;
+export type ExtractDroppedViewName<T> = T extends DropViewBuilder<infer TName> ? TName : never;
+export {};

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

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

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

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

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

@@ -0,0 +1,102 @@
+(_it = "alterTable addColumn") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    db.schema
+                        .createTable("users")
+                        .addColumn("username", "text", (col) => col.notNull().unique())
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    db.schema
+                        .alterTable("users")
+                        .addColumn("displayName", "text")
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable renameColumn and dropColumn") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    db.schema
+                        .createTable("users")
+                        .addColumn("username", "text")
+                        .addColumn("displayName", "text")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    db.schema
+                        .alterTable("users")
+                        .renameColumn("displayName", "nickname")
+                        .dropColumn("username")
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable alterColumn setDataType and setDefault") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    db.schema.createTable("users").addColumn("age", "integer").execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    db.schema
+                        .alterTable("users")
+                        .alterColumn("age", (col) => col.setDataType("text"))
+                        .alterColumn("age", (col) => col.setDefault("unknown"))
+                        .execute(),
+                ];
+            },
+        },
+    };
+    // todo(justinvdm, 2024-01-08): Support setDataType()
+    // @ts-ignore
+    (_test) => { };
+};
+(_it = "alterTable alterColumn dropDefault, setNotNull, dropNotNull") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    db.schema.createTable("users").addColumn("age", "integer").execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    db.schema
+                        .alterTable("users")
+                        .alterColumn("age", (col) => col.dropDefault())
+                        .alterColumn("age", (col) => col.setNotNull())
+                        .alterColumn("age", (col) => col.dropNotNull())
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+export {};

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

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

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

@@ -0,0 +1,33 @@
+(_it = "createTable") => {
+    const migrations = {
+        "001_init": {
+            async up(db) {
+                return [
+                    db.schema
+                        .createTable("users")
+                        .addColumn("username", "text", (col) => col.notNull().unique())
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "createTable with multiple columns and defaults") => {
+    const migrations = {
+        "001_init": {
+            async up(db) {
+                return [
+                    db.schema
+                        .createTable("users")
+                        .addColumn("username", "text", (col) => col.notNull())
+                        .addColumn("age", "integer", (col) => col.defaultTo(18))
+                        .addColumn("active", "boolean", (col) => col.defaultTo(true))
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+export {};

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

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

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

@@ -0,0 +1,77 @@
+(_it = "dropTable") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    db.schema
+                        .createTable("users")
+                        .addColumn("username", "text", (col) => col.notNull().unique())
+                        .execute(),
+                    db.schema.createTable("posts").addColumn("title", "text").execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [db.schema.dropTable("posts").execute()];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "dropTable non-existent table") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [db.schema.dropTable("ghost").execute()];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "dropTable all tables") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    db.schema.createTable("a").addColumn("x", "text").execute(),
+                    db.schema.createTable("b").addColumn("y", "text").execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    db.schema.dropTable("a").execute(),
+                    db.schema.dropTable("b").execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "chaining createTable and dropTable") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    db.schema
+                        .createTable("users")
+                        .addColumn("username", "text")
+                        .execute(),
+                    db.schema.createTable("posts").addColumn("title", "text").execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    db.schema.dropTable("posts").execute(),
+                    db.schema.createTable("comments").addColumn("text", "text").execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+export {};

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

@@ -0,0 +1,2 @@
+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;

package/dist/runtime/lib/db/typeInference/typetests/testUtils.js

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

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

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

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

@@ -0,0 +1,18 @@
+(_it = "addColumn with default value") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    db.schema
+                        .createTable("users")
+                        .addColumn("username", "text", (col) => col.notNull().unique())
+                        .addColumn("posts", "integer", (col) => col.defaultTo(0).notNull())
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+export {};
+// All tests for createTable, dropTable, and alterTable have been moved to their own files.

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

@@ -0,0 +1,14 @@
+export type SqlToTsType<T extends string> = T extends "text" ? string : T extends "integer" ? number : T extends "blob" ? Uint8Array : T extends "real" ? number : T extends "boolean" ? boolean : never;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type ExecutedBuilder<T> = Promise<void> & {
+    __builder_type: T;
+};
+export type MergeSchemas<A, B> = {
+    [K in keyof A | keyof B]: K extends keyof A ? K extends keyof B ? Prettify<A[K] & B[K]> : A[K] : K extends keyof B ? B[K] : never;
+};
+export type OmitNever<T> = {
+    [K in keyof T as T[K] extends never ? never : K]: T[K];
+};
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;

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

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

package/dist/vite/configPlugin.d.mts

@@ -1,10 +1,10 @@
 import { Plugin } from "vite";
 export declare const cloudflareBuiltInModules: string[];
 export declare const externalModules: string[];
-export declare const configPlugin: ({ mode, silent, projectRootDir, clientEntryPathname, workerEntryPathname, }: {
+export declare const configPlugin: ({ mode, silent, projectRootDir, clientEntryPathnames, workerEntryPathname, }: {
     mode: "development" | "production";
     silent: boolean;
     projectRootDir: string;
-    clientEntryPathname: string;
+    clientEntryPathnames: string[];
     workerEntryPathname: string;
 }) => Plugin;

package/dist/vite/configPlugin.mjs

@@ -15,7 +15,7 @@ export const externalModules = [
     ...builtinModules,
     ...builtinModules.map((m) => `node:${m}`),
 ];
-export const configPlugin = ({ mode, silent, projectRootDir, clientEntryPathname, workerEntryPathname, }) => ({
+export const configPlugin = ({ mode, silent, projectRootDir, clientEntryPathnames, workerEntryPathname, }) => ({
     name: "rwsdk:config",
     config: (_, { command }) => {
         const baseConfig = {
@@ -39,9 +39,7 @@ export const configPlugin = ({ mode, silent, projectRootDir, clientEntryPathname
                         outDir: resolve(projectRootDir, "dist", "client"),
                         manifest: true,
                         rollupOptions: {
-                            input: {
-                                client: clientEntryPathname,
-                            },
+                            input: clientEntryPathnames,
                         },
                     },
                     define: {

package/dist/vite/injectVitePreamblePlugin.d.mts

@@ -1,5 +1,5 @@
 import { type Plugin } from "vite";
-export declare const injectVitePreamble: ({ clientEntryPathname, mode, }: {
-    clientEntryPathname: string;
+export declare const injectVitePreamble: ({ clientEntryPathnames, mode, }: {
+    clientEntryPathnames: string[];
     mode: "development" | "production";
 }) => Plugin;

package/dist/vite/injectVitePreamblePlugin.mjs

@@ -1,9 +1,12 @@
 import MagicString from "magic-string";
-export const injectVitePreamble = ({ clientEntryPathname, mode, }) => ({
+export const injectVitePreamble = ({ clientEntryPathnames, mode, }) => ({
     name: "rwsdk:inject-vite-preamble",
     apply: "serve",
     transform(code, id) {
-        if (id !== clientEntryPathname) {
+        if (this.environment.name !== "client") {
+            return;
+        }
+        if (!clientEntryPathnames.includes(id)) {
             return;
         }
         // Only inject preamble in development mode

package/dist/vite/reactConditionsResolverPlugin.d.mts

@@ -13,4 +13,4 @@ export declare const ENV_RESOLVERS: {
 export declare const ENV_IMPORT_MAPPINGS: {
     [k: string]: Map<string, string>;
 };
-export declare const reactConditionsResolverPlugin: () => Promise<Plugin>;
+export declare const reactConditionsResolverPlugin: () => Plugin[];

package/dist/vite/reactConditionsResolverPlugin.mjs

@@ -95,71 +95,76 @@ function createEsbuildResolverPlugin(envName) {
         },
     };
 }
-export const reactConditionsResolverPlugin = async () => {
+export const reactConditionsResolverPlugin = () => {
     log("Initializing react conditions resolver plugin");
     let isBuild = false;
-    return {
-        name: "rwsdk:react-conditions-resolver",
-        enforce: "post",
-        config(config, { command }) {
-            isBuild = command === "build";
-            log("Configuring plugin for command=%s", command);
+    return [
+        {
+            name: "rwsdk:react-conditions-resolver:config",
+            enforce: "post",
+            config(config, { command }) {
+                isBuild = command === "build";
+                log("Configuring plugin for command=%s", command);
+            },
+            configResolved(config) {
+                log("Setting up resolve aliases and optimizeDeps for each environment");
+                // Set up aliases and optimizeDeps for each environment
+                for (const [envName, mappings] of Object.entries(ENV_IMPORT_MAPPINGS)) {
+                    const reactImports = ENV_REACT_IMPORTS[envName];
+                    // Ensure environment config exists
+                    if (!config.environments) {
+                        config.environments = {};
+                    }
+                    if (!config.environments[envName]) {
+                        config.environments[envName] = {};
+                    }
+                    const envConfig = config.environments[envName];
+                    const esbuildPlugin = createEsbuildResolverPlugin(envName);
+                    if (esbuildPlugin && mappings) {
+                        envConfig.optimizeDeps ??= {};
+                        envConfig.optimizeDeps.esbuildOptions ??= {};
+                        envConfig.optimizeDeps.esbuildOptions.define ??= {};
+                        envConfig.optimizeDeps.esbuildOptions.define["process.env.NODE_ENV"] = JSON.stringify(process.env.NODE_ENV ?? "production");
+                        envConfig.optimizeDeps.esbuildOptions.plugins ??= [];
+                        envConfig.optimizeDeps.esbuildOptions.plugins.push(esbuildPlugin);
+                        envConfig.optimizeDeps.include ??= [];
+                        envConfig.optimizeDeps.include.push(...reactImports);
+                        log("Added esbuild plugin and optimizeDeps includes for environment: %s", envName);
+                    }
+                    const aliases = ensureAliasArray(envConfig);
+                    for (const [find, replacement] of mappings) {
+                        const findRegex = new RegExp(`^${find.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&")}$`);
+                        aliases.push({ find: findRegex, replacement });
+                        log("Added alias for env=%s: %s -> %s", envName, find, replacement);
+                    }
+                    log("Environment %s configured with %d aliases and %d optimizeDeps includes", envName, mappings.size, reactImports.length);
+                }
+            },
         },
-        configResolved(config) {
-            log("Setting up resolve aliases and optimizeDeps for each environment");
-            // Set up aliases and optimizeDeps for each environment
-            for (const [envName, mappings] of Object.entries(ENV_IMPORT_MAPPINGS)) {
-                const reactImports = ENV_REACT_IMPORTS[envName];
-                // Ensure environment config exists
-                if (!config.environments) {
-                    config.environments = {};
+        {
+            name: "rwsdk:react-conditions-resolver:resolveId",
+            enforce: "pre",
+            async resolveId(id, importer) {
+                if (!isBuild) {
+                    return;
                 }
-                if (!config.environments[envName]) {
-                    config.environments[envName] = {};
+                const envName = this.environment?.name;
+                if (!envName) {
+                    return;
                 }
-                const envConfig = config.environments[envName];
-                const esbuildPlugin = createEsbuildResolverPlugin(envName);
-                if (esbuildPlugin && mappings) {
-                    envConfig.optimizeDeps ??= {};
-                    envConfig.optimizeDeps.esbuildOptions ??= {};
-                    envConfig.optimizeDeps.esbuildOptions.define ??= {};
-                    envConfig.optimizeDeps.esbuildOptions.define["process.env.NODE_ENV"] =
-                        JSON.stringify(process.env.NODE_ENV ?? "production");
-                    envConfig.optimizeDeps.esbuildOptions.plugins ??= [];
-                    envConfig.optimizeDeps.esbuildOptions.plugins.push(esbuildPlugin);
-                    envConfig.optimizeDeps.include ??= [];
-                    envConfig.optimizeDeps.include.push(...reactImports);
-                    log("Added esbuild plugin and optimizeDeps includes for environment: %s", envName);
+                verboseLog("Resolving id=%s, environment=%s, importer=%s", id, envName, importer);
+                const mappings = ENV_IMPORT_MAPPINGS[envName];
+                if (!mappings) {
+                    verboseLog("No mappings found for environment: %s", envName);
+                    return;
                 }
-                const aliases = ensureAliasArray(envConfig);
-                for (const [find, replacement] of mappings) {
-                    const findRegex = new RegExp(`^${find.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&")}$`);
-                    aliases.push({ find: findRegex, replacement });
-                    log("Added alias for env=%s: %s -> %s", envName, find, replacement);
+                const resolved = mappings.get(id);
+                if (resolved) {
+                    log("Resolved %s -> %s for env=%s", id, resolved, envName);
+                    return resolved;
                 }
-                log("Environment %s configured with %d aliases and %d optimizeDeps includes", envName, mappings.size, reactImports.length);
-            }
+                verboseLog("No resolution found for id=%s in env=%s", id, envName);
+            },
         },
-        async resolveId(id, importer) {
-            if (!isBuild) {
-                return;
-            }
-            const envName = this.environment?.name;
-            if (!envName) {
-                return;
-            }
-            verboseLog("Resolving id=%s, environment=%s, importer=%s", id, envName, importer);
-            const mappings = ENV_IMPORT_MAPPINGS[envName];
-            if (!mappings) {
-                verboseLog("No mappings found for environment: %s", envName);
-                return;
-            }
-            const resolved = mappings.get(id);
-            if (resolved) {
-                log("Resolved %s -> %s for env=%s", id, resolved, envName);
-                return resolved;
-            }
-            verboseLog("No resolution found for id=%s in env=%s", id, envName);
-        },
-    };
+    ];
 };

package/dist/vite/redwoodPlugin.d.mts

@@ -6,7 +6,7 @@ export type RedwoodPluginOptions = {
     includeCloudflarePlugin?: boolean;
     configPath?: string;
     entry?: {
-        client?: string;
+        client?: string | string[];
         worker?: string;
     };
 };

package/dist/vite/redwoodPlugin.mjs

@@ -1,4 +1,5 @@
 import { resolve } from "node:path";
+import { unstable_readConfig } from "wrangler";
 import { cloudflare } from "@cloudflare/vite-plugin";
 import { hasOwnCloudflareVitePlugin } from "./hasOwnCloudflareVitePlugin.mjs";
 import reactPlugin from "@vitejs/plugin-react";
@@ -20,12 +21,22 @@ import { prismaPlugin } from "./prismaPlugin.mjs";
 import { ssrBridgePlugin } from "./ssrBridgePlugin.mjs";
 import { hasPkgScript } from "../lib/hasPkgScript.mjs";
 import { devServerTimingPlugin } from "./devServerTimingPlugin.mjs";
+const determineWorkerEntryPathname = async (projectRootDir, workerConfigPath, options) => {
+    if (options.entry?.worker) {
+        return resolve(projectRootDir, options.entry.worker);
+    }
+    const workerConfig = unstable_readConfig({ config: workerConfigPath });
+    return resolve(projectRootDir, workerConfig.main ?? "src/worker.tsx");
+};
 export const redwoodPlugin = async (options = {}) => {
     const projectRootDir = process.cwd();
     const mode = options.mode ??
         (process.env.NODE_ENV === "development" ? "development" : "production");
-    const clientEntryPathname = resolve(projectRootDir, options?.entry?.client ?? "src/client.tsx");
-    const workerEntryPathname = resolve(projectRootDir, options?.entry?.worker ?? "src/worker.tsx");
+    const workerConfigPath = options.configPath ?? (await findWranglerConfig(projectRootDir));
+    const workerEntryPathname = await determineWorkerEntryPathname(projectRootDir, workerConfigPath, options);
+    const clientEntryPathnames = (Array.isArray(options.entry?.client)
+        ? options.entry.client
+        : [options.entry?.client ?? "src/client.tsx"]).map((entry) => resolve(projectRootDir, entry));
     const clientFiles = new Set();
     const serverFiles = new Set();
     const shouldIncludeCloudflarePlugin = options.includeCloudflarePlugin ??
@@ -49,7 +60,7 @@ export const redwoodPlugin = async (options = {}) => {
             mode,
             silent: options.silent ?? false,
             projectRootDir,
-            clientEntryPathname,
+            clientEntryPathnames,
             workerEntryPathname,
         }),
         ssrBridgePlugin({
@@ -62,7 +73,7 @@ export const redwoodPlugin = async (options = {}) => {
         shouldIncludeCloudflarePlugin
             ? cloudflare({
                 viteEnvironment: { name: "worker" },
-                configPath: options.configPath ?? (await findWranglerConfig(projectRootDir)),
+                configPath: workerConfigPath,
             })
             : [],
         miniflareHMRPlugin({
@@ -77,7 +88,7 @@ export const redwoodPlugin = async (options = {}) => {
             serverFiles,
         }),
         vitePreamblePlugin(),
-        injectVitePreamble({ clientEntryPathname, mode }),
+        injectVitePreamble({ clientEntryPathnames, mode }),
         useClientLookupPlugin({
             projectRootDir,
             clientFiles,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "0.1.0",
+  "version": "0.1.2-test.20250626055636",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {