@revojs/cloudflare 0.2.5 → 0.2.7

package/dist/index.d.ts

@@ -1,6 +1,11 @@
-import { type ScheduledEvent } from "@cloudflare/workers-types";
-declare const _default: {
-    fetch(request: Request, variables: Cloudflare.Env): Promise<Response | undefined>;
-    scheduled(event: ScheduledEvent, variables: Cloudflare.Env): Promise<void>;
+import type { DurableObjectNamespace, Workflow } from "@cloudflare/workers-types";
+import { type Scope } from "revojs";
+export type ScreamingSnake<Value extends string> = Value extends `${infer Head}${infer Next}${infer Tail}` ? `${Uppercase<Head>}${Head extends Lowercase<Head> ? (Next extends Lowercase<Next> ? "" : "_") : ""}${ScreamingSnake<`${Next}${Tail}`>}` : Uppercase<Value>;
+export type DurableObjects = {
+    [ClassName in keyof typeof import("#durable-objects") as ScreamingSnake<ClassName>]: DurableObjectNamespace<InstanceType<(typeof import("#durable-objects"))[ClassName]>>;
 };
-export default _default;
+export type Workflows = {
+    [ClassName in keyof typeof import("#workflows") as ScreamingSnake<ClassName>]: Workflow;
+};
+export declare function useDurableObjects(scope: Scope): DurableObjects;
+export declare function useWorkflows(scope: Scope): Workflows;

package/dist/index.js

@@ -1,70 +1,10 @@
-import "@cloudflare/workers-types";
-import { SCHEDULE_CONTEXT, SERVER_CONTEXT, isResponse, isWebSocket, sendResponse } from "@revojs/server";
-import { VARIABLE_CONTEXT, createScope } from "revojs";
+import { useVariables } from "revojs";
 //#region src/index.ts
-var src_default = {
-	async fetch(request, variables) {
-		const server = await import("#server").then((module) => module.default);
-		const scope = await createScope({ context: {
-			[VARIABLE_CONTEXT]: variables,
-			[SERVER_CONTEXT]: {
-				states: {},
-				request,
-				response: { headers: new Headers() }
-			}
-		} });
-		const result = await server.fetch(scope);
-		if (isResponse(result)) return result;
-		if (isWebSocket(result)) {
-			const [clientSocket, serverSocket] = new WebSocketPair();
-			const connection = {
-				async send(message) {
-					serverSocket.send(message);
-				},
-				async close(code, reason) {
-					serverSocket.close(code, reason);
-				}
-			};
-			serverSocket.addEventListener("open", async () => {
-				try {
-					await result.open(connection);
-				} catch (error) {
-					if (error instanceof Error) await result.error(connection, error);
-					else throw error;
-				}
-			});
-			serverSocket.addEventListener("message", async (event) => {
-				try {
-					await result.message(connection, event.data);
-				} catch (error) {
-					if (error instanceof Error) await result.error(connection, error);
-					else throw error;
-				}
-			});
-			serverSocket.addEventListener("error", async (event) => {
-				await result.error(connection, event.error);
-			});
-			serverSocket.addEventListener("close", async (event) => {
-				try {
-					await result.close(connection, event.code, event.reason);
-				} catch (error) {
-					if (error instanceof Error) await result.error(connection, error);
-					else throw error;
-				}
-			});
-			serverSocket.accept();
-			return sendResponse(scope, null, {
-				status: 101,
-				webSocket: clientSocket
-			});
-		}
-	},
-	async scheduled(event, variables) {
-		await (await import("#server").then((module) => module.default)).schedule(await createScope({ context: {
-			[VARIABLE_CONTEXT]: variables,
-			[SCHEDULE_CONTEXT]: { when: event.cron }
-		} }));
-	}
-};
+function useDurableObjects(scope) {
+	return useVariables(scope);
+}
+function useWorkflows(scope) {
+	return useVariables(scope);
+}
 //#endregion
-export { src_default as default };
+export { useDurableObjects, useWorkflows };

package/dist/module/index.js

@@ -1,8 +1,8 @@
 import { cloudflare } from "@cloudflare/vite-plugin";
 import server, { SERVER } from "@revojs/server/module";
 import { readFileSync } from "fs";
-import { addTypes, defineModule, resolvePaths, useModule } from "revojs/module";
-import { mergeObjects, scheduleAliases } from "revojs/shared";
+import { addTypes, defineModule, resolvePaths, resolveSource, useModule } from "revojs/module";
+import { mergeObjects, scheduleAliases, toExportNames } from "revojs/shared";
 //#region src/module/index.ts
 var module_default = defineModule({
 	name: "cloudflare",
@@ -15,19 +15,75 @@ var module_default = defineModule({
 			const content = readFileSync(path, "utf8");
 			for (const match of content.matchAll(SCHEDULE_WHEN_MATCH)) crons.add(scheduleAliases[match[1].trim().toLowerCase()] ?? match[1].trim());
 		}
-		addTypes(config, "cloudflare", () => `import "@cloudflare/workers-types"`);
+		const durableObjects = {
+			match: [
+				"**/*.js",
+				"**/*.ts",
+				"!*.d.ts"
+			],
+			from: ["./durable-objects"],
+			format: "named"
+		};
+		const workflows = {
+			match: [
+				"**/*.js",
+				"**/*.ts",
+				"!*.d.ts"
+			],
+			from: ["./workflows"],
+			format: "named"
+		};
+		const durableObjectKeys = new Array();
+		for (const files of resolveSource(durableObjects).values()) for (const key of files.keys()) durableObjectKeys.push(key);
+		const workflowKeys = new Array();
+		for (const files of resolveSource(workflows).values()) for (const key of files.keys()) workflowKeys.push(key);
+		const durableObjectNames = toExportNames(durableObjectKeys);
+		const workflowNames = toExportNames(workflowKeys);
+		const durableObjectBindings = durableObjectNames.map((className) => ({
+			name: className.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase(),
+			class_name: className
+		}));
+		const workflowBindings = workflowNames.map((className) => ({
+			binding: className.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase(),
+			name: className.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(),
+			class_name: className
+		}));
+		const exportsMap = {};
+		for (const className of durableObjectNames) exportsMap[className] = {
+			type: "durable-object",
+			storage: "sqlite"
+		};
+		addTypes(config, "cloudflare", () => `/// <reference types="@cloudflare/workers-types" />`);
 		const options = mergeObjects(config.cloudflare, {
 			viteEnvironment: { name: SERVER },
 			config: {
-				main: fromModule("../index.js"),
+				main: fromModule("../server/index.js"),
 				assets: { run_worker_first: ["/"] },
+				durable_objects: { bindings: durableObjectBindings },
+				workflows: workflowBindings,
+				exports: exportsMap,
 				triggers: { crons: [...crons] }
 			}
 		});
-		return { vite: {
-			server: { watch: { ignored: ["**/.wrangler/**"] } },
-			plugins: [cloudflare(options)]
-		} };
+		return {
+			sources: {
+				"durable-objects": durableObjects,
+				entrypoints: {
+					match: [
+						"**/*.js",
+						"**/*.ts",
+						"!*.d.ts"
+					],
+					from: ["./entrypoints"],
+					format: "named"
+				},
+				workflows
+			},
+			vite: {
+				server: { watch: { ignored: ["**/.wrangler/**"] } },
+				plugins: [cloudflare(options)]
+			}
+		};
 	}
 });
 var SCHEDULE_WHEN_MATCH = /when\s*:\s*["'`]([^"'`\n]+)["'`]/g;

package/dist/server/index.d.ts

@@ -0,0 +1,9 @@
+import { type ScheduledEvent } from "@cloudflare/workers-types";
+export * from "#durable-objects";
+export * from "#entrypoints";
+export * from "#workflows";
+declare const _default: {
+    fetch(request: Request, variables: Cloudflare.Env): Promise<Response | undefined>;
+    scheduled(event: ScheduledEvent, variables: Cloudflare.Env): Promise<void>;
+};
+export default _default;

package/dist/server/index.js

@@ -0,0 +1,73 @@
+import { VARIABLE_CONTEXT, createScope } from "revojs";
+import "@cloudflare/workers-types";
+import { SCHEDULE_CONTEXT, SERVER_CONTEXT, isResponse, isWebSocket, sendResponse } from "@revojs/server";
+export * from "#durable-objects";
+export * from "#entrypoints";
+export * from "#workflows";
+//#region src/server/index.ts
+var server_default = {
+	async fetch(request, variables) {
+		const server = await import("#server").then((module) => module.default);
+		const scope = await createScope({ context: {
+			[VARIABLE_CONTEXT]: variables,
+			[SERVER_CONTEXT]: {
+				states: {},
+				request,
+				response: { headers: new Headers() }
+			}
+		} });
+		const result = await server.fetch(scope);
+		if (isResponse(result)) return result;
+		if (isWebSocket(result)) {
+			const [clientSocket, serverSocket] = new WebSocketPair();
+			const connection = {
+				async send(message) {
+					serverSocket.send(message);
+				},
+				async close(code, reason) {
+					serverSocket.close(code, reason);
+				}
+			};
+			serverSocket.addEventListener("open", async () => {
+				try {
+					await result.open(connection);
+				} catch (error) {
+					if (error instanceof Error) await result.error(connection, error);
+					else throw error;
+				}
+			});
+			serverSocket.addEventListener("message", async (event) => {
+				try {
+					await result.message(connection, event.data);
+				} catch (error) {
+					if (error instanceof Error) await result.error(connection, error);
+					else throw error;
+				}
+			});
+			serverSocket.addEventListener("error", async (event) => {
+				await result.error(connection, event.error);
+			});
+			serverSocket.addEventListener("close", async (event) => {
+				try {
+					await result.close(connection, event.code, event.reason);
+				} catch (error) {
+					if (error instanceof Error) await result.error(connection, error);
+					else throw error;
+				}
+			});
+			serverSocket.accept();
+			return sendResponse(scope, null, {
+				status: 101,
+				webSocket: clientSocket
+			});
+		}
+	},
+	async scheduled(event, variables) {
+		await (await import("#server").then((module) => module.default)).schedule(await createScope({ context: {
+			[VARIABLE_CONTEXT]: variables,
+			[SCHEDULE_CONTEXT]: { when: event.cron }
+		} }));
+	}
+};
+//#endregion
+export { server_default as default };

package/dist/types/index.d.ts

@@ -0,0 +1,20 @@
+declare module "#durable-objects" {
+    import type { DurableObject } from "cloudflare:workers";
+
+    const durableObject: typeof DurableObject;
+    export { durableObject };
+}
+
+declare module "#workflows" {
+    import type { WorkflowEntrypoint } from "cloudflare:workers";
+
+    const workflow: typeof WorkflowEntrypoint;
+    export { workflow };
+}
+
+declare module "#entrypoints" {
+    import type { WorkerEntrypoint } from "cloudflare:workers";
+
+    const entrypoint: typeof WorkerEntrypoint;
+    export { entrypoint };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@revojs/cloudflare",
-    "version": "0.2.5",
+    "version": "0.2.7",
     "license": "MIT",
     "repository": {
         "type": "git",
@@ -10,7 +10,14 @@
         "dist"
     ],
     "type": "module",
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
     "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        },
         "./module": {
             "types": "./dist/module/index.d.ts",
             "import": "./dist/module/index.js"
@@ -21,11 +28,11 @@
         "watch": "vite build --watch"
     },
     "dependencies": {
-        "@cloudflare/vite-plugin": "^1.54.8",
-        "@cloudflare/workers-types": "^5.20260911.1",
+        "@cloudflare/vite-plugin": "^1.62.5",
+        "@cloudflare/workers-types": "^5.20261004.1",
         "@revojs/server": "*",
         "revojs": "*",
-        "wrangler": "^4.131.1"
+        "wrangler": "^4.147.0"
     },
     "devDependencies": {
         "@revojs/tsconfig": "*"