@livestore/sync-cf 0.3.0-dev.5 → 0.3.0-dev.51

package/src/cf-worker/worker.ts

@@ -0,0 +1,129 @@
+import { UnexpectedError } from '@livestore/common'
+import type { Schema } from '@livestore/utils/effect'
+import { Effect, UrlParams } from '@livestore/utils/effect'
+
+import { SearchParamsSchema } from '../common/mod.js'
+import type { Env } from './durable-object.js'
+
+export type CFWorker = {
+  fetch: (request: Request, env: Env, ctx: ExecutionContext) => Promise<Response>
+}
+
+export type MakeWorkerOptions = {
+  validatePayload?: (payload: Schema.JsonValue | undefined) => void | Promise<void>
+  /** @default false */
+  enableCORS?: boolean
+}
+
+export const makeWorker = (options: MakeWorkerOptions = {}): CFWorker => {
+  return {
+    fetch: async (request, env, _ctx) => {
+      const url = new URL(request.url)
+
+      if (request.method === 'GET' && url.pathname === '/') {
+        return new Response('Info: WebSocket sync backend endpoint for @livestore/sync-cf.', {
+          status: 200,
+          headers: { 'Content-Type': 'text/plain' },
+        })
+      }
+
+      const corsHeaders: HeadersInit = options.enableCORS
+        ? {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+            'Access-Control-Allow-Headers': request.headers.get('Access-Control-Request-Headers') ?? '*',
+          }
+        : {}
+
+      if (request.method === 'OPTIONS' && options.enableCORS) {
+        return new Response(null, {
+          status: 204,
+          headers: corsHeaders,
+        })
+      }
+
+      if (url.pathname.endsWith('/websocket')) {
+        return handleWebSocket(request, env, _ctx, { headers: corsHeaders, validatePayload: options.validatePayload })
+      }
+
+      console.error('Invalid path', url.pathname)
+
+      return new Response('Invalid path', {
+        status: 400,
+        statusText: 'Bad Request',
+        headers: {
+          ...corsHeaders,
+          'Content-Type': 'text/plain',
+        },
+      })
+    },
+  }
+}
+
+/**
+ * Handles `/websocket` endpoint.
+ *
+ * @example
+ * ```ts
+ * const validatePayload = (payload: Schema.JsonValue | undefined) => {
+ *   if (payload?.authToken !== 'insecure-token-change-me') {
+ *     throw new Error('Invalid auth token')
+ *   }
+ * }
+ *
+ * export default {
+ *   fetch: async (request, env, ctx) => {
+ *     if (request.url.endsWith('/websocket')) {
+ *       return handleWebSocket(request, env, ctx, { headers: {}, validatePayload })
+ *     }
+ *
+ *     return new Response('Invalid path', { status: 400, headers: corsHeaders })
+ *   }
+ * }
+ * ```
+ *
+ * @throws {UnexpectedError} If the payload is invalid
+ */
+export const handleWebSocket = (
+  request: Request,
+  env: Env,
+  _ctx: ExecutionContext,
+  options: { headers?: HeadersInit; validatePayload?: (payload: Schema.JsonValue | undefined) => void | Promise<void> },
+): Promise<Response> =>
+  Effect.gen(function* () {
+    const url = new URL(request.url)
+
+    const urlParams = UrlParams.fromInput(url.searchParams)
+    const paramsResult = yield* UrlParams.schemaStruct(SearchParamsSchema)(urlParams).pipe(Effect.either)
+
+    if (paramsResult._tag === 'Left') {
+      return new Response(`Invalid search params: ${paramsResult.left.toString()}`, {
+        status: 500,
+        headers: options?.headers,
+      })
+    }
+
+    const { storeId, payload } = paramsResult.right
+
+    if (options.validatePayload !== undefined) {
+      const result = yield* Effect.promise(async () => options.validatePayload!(payload)).pipe(
+        UnexpectedError.mapToUnexpectedError,
+        Effect.either,
+      )
+
+      if (result._tag === 'Left') {
+        console.error('Invalid payload', result.left)
+        return new Response(result.left.toString(), { status: 400, headers: options.headers })
+      }
+    }
+
+    const id = env.WEBSOCKET_SERVER.idFromName(storeId)
+    const durableObject = env.WEBSOCKET_SERVER.get(id)
+
+    const upgradeHeader = request.headers.get('Upgrade')
+    if (!upgradeHeader || upgradeHeader !== 'websocket') {
+      return new Response('Durable Object expected Upgrade: websocket', { status: 426, headers: options?.headers })
+    }
+
+    return yield* Effect.promise(() => durableObject.fetch(request))
+  }).pipe(Effect.tapCauseLogPretty, Effect.runPromise)

package/src/common/mod.ts

@@ -0,0 +1,8 @@
+import { Schema } from '@livestore/utils/effect'
+
+export * as WSMessage from './ws-message-types.js'
+
+export const SearchParamsSchema = Schema.Struct({
+  storeId: Schema.String,
+  payload: Schema.compose(Schema.StringFromUriComponent, Schema.parseJson(Schema.JsonValue)).pipe(Schema.UndefinedOr),
+})

package/src/common/ws-message-types.ts

@@ -1,89 +1,83 @@
-import { MutationEvent } from '@livestore/common/schema'
+import { LiveStoreEvent } from '@livestore/common/schema'
 import { Schema } from '@livestore/utils/effect'
 
 export const PullReq = Schema.TaggedStruct('WSMessage.PullReq', {
   requestId: Schema.String,
   /** Omitting the cursor will start from the beginning */
   cursor: Schema.optional(Schema.Number),
-})
+}).annotations({ title: '@livestore/sync-cf:PullReq' })
 
 export type PullReq = typeof PullReq.Type
 
 export const SyncMetadata = Schema.Struct({
   /** ISO date format */
   createdAt: Schema.String,
-})
+}).annotations({ title: '@livestore/sync-cf:SyncMetadata' })
 
 export type SyncMetadata = typeof SyncMetadata.Type
 
 export const PullRes = Schema.TaggedStruct('WSMessage.PullRes', {
-  requestId: Schema.String,
-  events: Schema.Array(
+  batch: Schema.Array(
     Schema.Struct({
-      mutationEventEncoded: MutationEvent.AnyEncodedGlobal,
+      eventEncoded: LiveStoreEvent.AnyEncodedGlobal,
       metadata: Schema.Option(SyncMetadata),
     }),
   ),
+  requestId: Schema.Struct({ context: Schema.Literal('pull', 'push'), requestId: Schema.String }),
   remaining: Schema.Number,
-})
+}).annotations({ title: '@livestore/sync-cf:PullRes' })
 
 export type PullRes = typeof PullRes.Type
 
-export const PushBroadcast = Schema.TaggedStruct('WSMessage.PushBroadcast', {
-  mutationEventEncoded: MutationEvent.AnyEncodedGlobal,
-  metadata: Schema.Option(SyncMetadata),
-})
-
-export type PushBroadcast = typeof PushBroadcast.Type
-
 export const PushReq = Schema.TaggedStruct('WSMessage.PushReq', {
   requestId: Schema.String,
-  batch: Schema.Array(MutationEvent.AnyEncodedGlobal),
-})
+  batch: Schema.Array(LiveStoreEvent.AnyEncodedGlobal),
+}).annotations({ title: '@livestore/sync-cf:PushReq' })
 
 export type PushReq = typeof PushReq.Type
 
 export const PushAck = Schema.TaggedStruct('WSMessage.PushAck', {
   requestId: Schema.String,
-  mutationId: Schema.Number,
-})
+}).annotations({ title: '@livestore/sync-cf:PushAck' })
 
 export type PushAck = typeof PushAck.Type
 
 export const Error = Schema.TaggedStruct('WSMessage.Error', {
   requestId: Schema.String,
   message: Schema.String,
-})
+}).annotations({ title: '@livestore/sync-cf:Error' })
+
+export type Error = typeof Error.Type
 
 export const Ping = Schema.TaggedStruct('WSMessage.Ping', {
   requestId: Schema.Literal('ping'),
-})
+}).annotations({ title: '@livestore/sync-cf:Ping' })
 
 export type Ping = typeof Ping.Type
 
 export const Pong = Schema.TaggedStruct('WSMessage.Pong', {
   requestId: Schema.Literal('ping'),
-})
+}).annotations({ title: '@livestore/sync-cf:Pong' })
 
 export type Pong = typeof Pong.Type
 
 export const AdminResetRoomReq = Schema.TaggedStruct('WSMessage.AdminResetRoomReq', {
   requestId: Schema.String,
   adminSecret: Schema.String,
-})
+}).annotations({ title: '@livestore/sync-cf:AdminResetRoomReq' })
 
 export type AdminResetRoomReq = typeof AdminResetRoomReq.Type
 
 export const AdminResetRoomRes = Schema.TaggedStruct('WSMessage.AdminResetRoomRes', {
   requestId: Schema.String,
-})
+}).annotations({ title: '@livestore/sync-cf:AdminResetRoomRes' })
 
 export type AdminResetRoomRes = typeof AdminResetRoomRes.Type
 
 export const AdminInfoReq = Schema.TaggedStruct('WSMessage.AdminInfoReq', {
   requestId: Schema.String,
   adminSecret: Schema.String,
-})
+}).annotations({ title: '@livestore/sync-cf:AdminInfoReq' })
 
 export type AdminInfoReq = typeof AdminInfoReq.Type
 
@@ -92,14 +86,13 @@ export const AdminInfoRes = Schema.TaggedStruct('WSMessage.AdminInfoRes', {
   info: Schema.Struct({
     durableObjectId: Schema.String,
   }),
-})
+}).annotations({ title: '@livestore/sync-cf:AdminInfoRes' })
 
 export type AdminInfoRes = typeof AdminInfoRes.Type
 
 export const Message = Schema.Union(
   PullReq,
   PullRes,
-  PushBroadcast,
   PushReq,
   PushAck,
   Error,
@@ -109,19 +102,12 @@ export const Message = Schema.Union(
   AdminResetRoomRes,
   AdminInfoReq,
   AdminInfoRes,
-)
+).annotations({ title: '@livestore/sync-cf:Message' })
+
 export type Message = typeof Message.Type
 export type MessageEncoded = typeof Message.Encoded
 
-export const BackendToClientMessage = Schema.Union(
-  PullRes,
-  PushBroadcast,
-  PushAck,
-  AdminResetRoomRes,
-  AdminInfoRes,
-  Error,
-  Pong,
-)
+export const BackendToClientMessage = Schema.Union(PullRes, PushAck, AdminResetRoomRes, AdminInfoRes, Error, Pong)
 export type BackendToClientMessage = typeof BackendToClientMessage.Type
 
 export const ClientToBackendMessage = Schema.Union(PullReq, PushReq, AdminResetRoomReq, AdminInfoReq, Ping)

package/src/sync-impl/ws-impl.ts

@@ -1,9 +1,9 @@
 /// <reference lib="dom" />
 
-import type { SyncBackend, SyncBackendOptionsBase } from '@livestore/common'
-import { InvalidPullError, InvalidPushError } from '@livestore/common'
-import { pick } from '@livestore/utils'
-import type { Scope } from '@livestore/utils/effect'
+import type { SyncBackend, SyncBackendConstructor } from '@livestore/common'
+import { InvalidPullError, InvalidPushError, UnexpectedError } from '@livestore/common'
+import { EventSequenceNumber } from '@livestore/common/schema'
+import { LS_DEV, shouldNeverHappen } from '@livestore/utils'
 import {
   Deferred,
   Effect,
@@ -14,98 +14,139 @@ import {
   Schema,
   Stream,
   SubscriptionRef,
+  UrlParams,
   WebSocket,
 } from '@livestore/utils/effect'
 import { nanoid } from '@livestore/utils/nanoid'
 
-import { WSMessage } from '../common/index.js'
+import { SearchParamsSchema, WSMessage } from '../common/mod.js'
 import type { SyncMetadata } from '../common/ws-message-types.js'
 
-export interface WsSyncOptions extends SyncBackendOptionsBase {
-  type: 'cf'
+export interface WsSyncOptions {
   url: string
-  roomId: string
 }
 
-interface LiveStoreGlobalCf {
-  syncBackend: WsSyncOptions
-}
-
-declare global {
-  interface LiveStoreGlobal extends LiveStoreGlobalCf {}
-}
-
-export const makeWsSync = (options: WsSyncOptions): Effect.Effect<SyncBackend<SyncMetadata>, never, Scope.Scope> =>
-  Effect.gen(function* () {
-    const wsUrl = `${options.url}/websocket?room=${options.roomId}`
-
-    const { isConnected, incomingMessages, send } = yield* connect(wsUrl)
-
-    const api = {
-      isConnected,
-      pull: (args) =>
-        Effect.gen(function* () {
-          const requestId = nanoid()
-          const cursor = Option.getOrUndefined(args)?.cursor.global
-
-          yield* send(WSMessage.PullReq.make({ cursor, requestId }))
-
-          return Stream.fromPubSub(incomingMessages).pipe(
-            Stream.filter((_) => (_._tag === 'WSMessage.PullRes' ? _.requestId === requestId : true)),
-            Stream.tap((_) =>
-              _._tag === 'WSMessage.Error' && _.requestId === requestId
-                ? new InvalidPullError({ message: _.message })
-                : Effect.void,
-            ),
-            Stream.filter(Schema.is(Schema.Union(WSMessage.PushBroadcast, WSMessage.PullRes))),
-            Stream.map((msg) =>
-              msg._tag === 'WSMessage.PushBroadcast'
-                ? { batch: [pick(msg, ['mutationEventEncoded', 'metadata'])], remaining: 0 }
-                : {
-                    batch: msg.events.map(({ mutationEventEncoded, metadata }) => ({
-                      mutationEventEncoded,
-                      metadata,
-                    })),
-                    remaining: msg.remaining,
-                  },
-            ),
-          )
-        }).pipe(Stream.unwrap),
-
-      push: (batch) =>
-        Effect.gen(function* () {
-          const ready = yield* Deferred.make<void, InvalidPushError>()
-          const requestId = nanoid()
-
-          yield* Stream.fromPubSub(incomingMessages).pipe(
-            Stream.filter((_) => _._tag !== 'WSMessage.PushBroadcast' && _.requestId === requestId),
-            Stream.tap((_) =>
-              _._tag === 'WSMessage.Error'
-                ? Deferred.fail(ready, new InvalidPushError({ reason: { _tag: 'Unexpected', message: _.message } }))
-                : Effect.void,
-            ),
-            Stream.filter(Schema.is(WSMessage.PushAck)),
-            // TODO bring back filterting of "own events"
-            // Stream.filter((_) => _.mutationId === mutationEventEncoded.id.global),
-            Stream.take(1),
-            Stream.tap(() => Deferred.succeed(ready, void 0)),
-            Stream.runDrain,
-            Effect.tapCauseLogPretty,
-            Effect.fork,
-          )
-
-          yield* send(WSMessage.PushReq.make({ batch, requestId }))
-
-          yield* ready
-
-          const createdAt = new Date().toISOString()
-
-          return { metadata: Array.from({ length: batch.length }, () => Option.some({ createdAt })) }
-        }),
-    } satisfies SyncBackend<SyncMetadata>
+export const makeCfSync =
+  (options: WsSyncOptions): SyncBackendConstructor<SyncMetadata> =>
+  ({ storeId, payload }) =>
+    Effect.gen(function* () {
+      const urlParamsData = yield* Schema.encode(SearchParamsSchema)({
+        storeId,
+        payload,
+      }).pipe(UnexpectedError.mapToUnexpectedError)
+
+      const urlParams = UrlParams.fromInput(urlParamsData)
+      const wsUrl = `${options.url}/websocket?${UrlParams.toString(urlParams)}`
+
+      const { isConnected, incomingMessages, send } = yield* connect(wsUrl)
+
+      /**
+       * We need to account for the scenario where push-caused PullRes message arrive before the pull-caused PullRes message.
+       * i.e. a scenario where the WS connection is created but before the server processed the initial pull, a push from
+       * another client triggers a PullRes message sent to this client which we need to stash until our pull-caused
+       * PullRes message arrives at which point we can combine the stashed events with the pull-caused events and continue.
+       */
+      const stashedPullBatch: WSMessage.PullRes['batch'][number][] = []
+
+      // We currently only support one pull stream for a sync backend.
+      let pullStarted = false
+
+      const api = {
+        isConnected,
+        // Currently we're already eagerly connecting when the sync backend is created but we might want to refactor this later to clean this up
+        connect: Effect.void,
+        pull: (args) =>
+          Effect.gen(function* () {
+            if (pullStarted) {
+              return shouldNeverHappen(`Pull already started for this sync backend.`)
+            }
 
-    return api
-  })
+            pullStarted = true
+
+            let pullResponseReceived = false
+
+            const requestId = nanoid()
+            const cursor = Option.getOrUndefined(args)?.cursor.global
+
+            yield* send(WSMessage.PullReq.make({ cursor, requestId }))
+
+            return Stream.fromPubSub(incomingMessages).pipe(
+              Stream.tap((_) =>
+                _._tag === 'WSMessage.Error' && _.requestId === requestId
+                  ? new InvalidPullError({ message: _.message })
+                  : Effect.void,
+              ),
+              Stream.filterMap((msg) => {
+                if (msg._tag === 'WSMessage.PullRes') {
+                  if (msg.requestId.context === 'pull') {
+                    if (msg.requestId.requestId === requestId) {
+                      pullResponseReceived = true
+
+                      if (stashedPullBatch.length > 0 && msg.remaining === 0) {
+                        const pullResHead = msg.batch.at(-1)?.eventEncoded.seqNum ?? EventSequenceNumber.ROOT.global
+                        // Index where stashed events are greater than pullResHead
+                        const newPartialBatchIndex = stashedPullBatch.findIndex(
+                          (batchItem) => batchItem.eventEncoded.seqNum > pullResHead,
+                        )
+                        const batchWithNewStashedEvents =
+                          newPartialBatchIndex === -1 ? [] : stashedPullBatch.slice(newPartialBatchIndex)
+                        const combinedBatch = [...msg.batch, ...batchWithNewStashedEvents]
+                        return Option.some({ ...msg, batch: combinedBatch, remaining: 0 })
+                      } else {
+                        return Option.some(msg)
+                      }
+                    } else {
+                      // Ignore
+                      return Option.none()
+                    }
+                  } else {
+                    if (pullResponseReceived) {
+                      return Option.some(msg)
+                    } else {
+                      stashedPullBatch.push(...msg.batch)
+                      return Option.none()
+                    }
+                  }
+                }
+
+                return Option.none()
+              }),
+            )
+          }).pipe(Stream.unwrap),
+
+        push: (batch) =>
+          Effect.gen(function* () {
+            const pushAck = yield* Deferred.make<void, InvalidPushError>()
+            const requestId = nanoid()
+
+            yield* Stream.fromPubSub(incomingMessages).pipe(
+              Stream.tap((_) =>
+                _._tag === 'WSMessage.Error' && _.requestId === requestId
+                  ? Deferred.fail(pushAck, new InvalidPushError({ reason: { _tag: 'Unexpected', message: _.message } }))
+                  : Effect.void,
+              ),
+              Stream.filter((_) => _._tag === 'WSMessage.PushAck' && _.requestId === requestId),
+              Stream.take(1),
+              Stream.tap(() => Deferred.succeed(pushAck, void 0)),
+              Stream.runDrain,
+              Effect.tapCauseLogPretty,
+              Effect.fork,
+            )
+
+            yield* send(WSMessage.PushReq.make({ batch, requestId }))
+
+            yield* pushAck
+          }),
+        metadata: {
+          name: '@livestore/cf-sync',
+          description: 'LiveStore sync backend implementation using Cloudflare Workers & Durable Objects',
+          protocol: 'ws',
+          url: options.url,
+        },
+      } satisfies SyncBackend<SyncMetadata>
+
+      return api
+    })
 
 const connect = (wsUrl: string) =>
   Effect.gen(function* () {
@@ -123,21 +164,23 @@ const connect = (wsUrl: string) =>
         // Wait first until we're online
         yield* waitUntilOnline
 
-        yield* Effect.spanEvent(
-          `Sending message: ${message._tag}`,
-          message._tag === 'WSMessage.PushReq'
-            ? {
-                id: message.batch[0]!.id.global,
-                parentId: message.batch[0]!.parentId.global,
-                batchLength: message.batch.length,
-              }
-            : message._tag === 'WSMessage.PullReq'
-              ? { cursor: message.cursor ?? '-' }
-              : {},
-        )
-
         // TODO use MsgPack instead of JSON to speed up the serialization / reduce the size of the messages
         socketRef.current!.send(Schema.encodeSync(Schema.parseJson(WSMessage.Message))(message))
+
+        if (LS_DEV) {
+          yield* Effect.spanEvent(
+            `Sent message: ${message._tag}`,
+            message._tag === 'WSMessage.PushReq'
+              ? {
+                  seqNum: message.batch[0]!.seqNum,
+                  parentSeqNum: message.batch[0]!.parentSeqNum,
+                  batchLength: message.batch.length,
+                }
+              : message._tag === 'WSMessage.PullReq'
+                ? { cursor: message.cursor ?? '-' }
+                : {},
+          )
+        }
       })
 
     const innerConnect = Effect.gen(function* () {
@@ -146,11 +189,13 @@ const connect = (wsUrl: string) =>
       while (typeof navigator !== 'undefined' && navigator.onLine === false) {
         yield* Effect.sleep(1000)
       }
+      // TODO bring this back in a cross-platform way
       // if (navigator.onLine === false) {
       //   yield* Effect.async((cb) => self.addEventListener('online', () => cb(Effect.void)))
       // }
 
       const socket = yield* WebSocket.makeWebSocket({ url: wsUrl, reconnect: Schedule.exponential(100) })
+      // socket.binaryType = 'arraybuffer'
 
       yield* SubscriptionRef.set(isConnected, true)
       socketRef.current = socket
@@ -191,7 +236,8 @@ const connect = (wsUrl: string) =>
       // NOTE it seems that this callback doesn't work reliably on a worker but only via `window.addEventListener`
       // We might need to proxy the event from the main thread to the worker if we want this to work reliably.
       // eslint-disable-next-line unicorn/prefer-global-this
-      if (typeof self !== 'undefined') {
+      if (typeof self !== 'undefined' && typeof self.addEventListener === 'function') {
+        // TODO support an Expo equivalent for this
         // eslint-disable-next-line unicorn/prefer-global-this
         yield* Effect.eventListener(self, 'offline', () => Deferred.succeed(connectionClosed, void 0))
       }

package/dist/cf-worker/index.d.ts

@@ -1,8 +0,0 @@
-/// <reference no-default-lib="true"/>
-import type { Env } from './durable-object.js';
-export * from './durable-object.js';
-declare const _default: {
-    fetch: (request: Request, env: Env, _ctx: ExecutionContext) => Promise<Response>;
-};
-export default _default;
-//# sourceMappingURL=index.d.ts.map

package/dist/cf-worker/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cf-worker/index.ts"],"names":[],"mappings":";AAMA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAA;AAE9C,cAAc,qBAAqB,CAAA;;qBA4CV,OAAO,OAAO,GAAG,QAAQ,gBAAgB,KAAG,OAAO,CAAC,QAAQ,CAAC;;AADtF,wBAgCC"}

package/dist/cf-worker/index.js

@@ -1,67 +0,0 @@
-/// <reference no-default-lib="true"/>
-/// <reference lib="esnext" />
-export * from './durable-object.js';
-// const handleRequest = (request: Request, env: Env) =>
-//   HttpServer.router.empty.pipe(
-//     HttpServer.router.get(
-//       '/websocket',
-//       Effect.gen(function* () {
-//         // This example will refer to the same Durable Object instance,
-//         // since the name "foo" is hardcoded.
-//         const id = env.WEBSOCKET_SERVER.idFromName('foo')
-//         const durableObject = env.WEBSOCKET_SERVER.get(id)
-//         HttpServer.
-//         // Expect to receive a WebSocket Upgrade request.
-//         // If there is one, accept the request and return a WebSocket Response.
-//         const headerRes = yield* HttpServer.request
-//           .schemaHeaders(
-//             Schema.Struct({
-//               Upgrade: Schema.Literal('websocket'),
-//             }),
-//           )
-//           .pipe(Effect.either)
-//         if (headerRes._tag === 'Left') {
-//           // return new Response('Durable Object expected Upgrade: websocket', { status: 426 })
-//           return yield* HttpServer.response.text('Durable Object expected Upgrade: websocket', { status: 426 })
-//         }
-//         HttpServer.response.empty
-//         return yield* Effect.promise(() => durableObject.fetch(request))
-//       }),
-//     ),
-//     HttpServer.router.catchAll((e) => {
-//       console.log(e)
-//       return HttpServer.response.empty({ status: 400 })
-//     }),
-//     (_) => HttpServer.app.toWebHandler(_)(request),
-//     // request
-//   )
-// Worker
-export default {
-    fetch: async (request, env, _ctx) => {
-        const url = new URL(request.url);
-        const searchParams = url.searchParams;
-        const roomId = searchParams.get('room');
-        if (roomId === null) {
-            return new Response('Room ID is required', { status: 400 });
-        }
-        // This example will refer to the same Durable Object instance,
-        // since the name "foo" is hardcoded.
-        const id = env.WEBSOCKET_SERVER.idFromName(roomId);
-        const durableObject = env.WEBSOCKET_SERVER.get(id);
-        if (url.pathname.endsWith('/websocket')) {
-            const upgradeHeader = request.headers.get('Upgrade');
-            if (!upgradeHeader || upgradeHeader !== 'websocket') {
-                return new Response('Durable Object expected Upgrade: websocket', { status: 426 });
-            }
-            return durableObject.fetch(request);
-        }
-        return new Response(null, {
-            status: 400,
-            statusText: 'Bad Request',
-            headers: {
-                'Content-Type': 'text/plain',
-            },
-        });
-    },
-};
-//# sourceMappingURL=index.js.map

package/dist/cf-worker/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/cf-worker/index.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,8BAA8B;AAO9B,cAAc,qBAAqB,CAAA;AAEnC,wDAAwD;AACxD,kCAAkC;AAClC,6BAA6B;AAC7B,sBAAsB;AACtB,kCAAkC;AAClC,0EAA0E;AAC1E,gDAAgD;AAChD,4DAA4D;AAC5D,6DAA6D;AAE7D,sBAAsB;AAEtB,4DAA4D;AAC5D,kFAAkF;AAClF,sDAAsD;AACtD,4BAA4B;AAC5B,8BAA8B;AAC9B,sDAAsD;AACtD,kBAAkB;AAClB,cAAc;AACd,iCAAiC;AAEjC,2CAA2C;AAC3C,kGAAkG;AAClG,kHAAkH;AAClH,YAAY;AAEZ,oCAAoC;AAEpC,2EAA2E;AAC3E,YAAY;AACZ,SAAS;AACT,0CAA0C;AAC1C,uBAAuB;AACvB,0DAA0D;AAC1D,UAAU;AACV,sDAAsD;AACtD,iBAAiB;AACjB,MAAM;AAEN,SAAS;AACT,eAAe;IACb,KAAK,EAAE,KAAK,EAAE,OAAgB,EAAE,GAAQ,EAAE,IAAsB,EAAqB,EAAE;QACrF,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;QAChC,MAAM,YAAY,GAAG,GAAG,CAAC,YAAY,CAAA;QACrC,MAAM,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;QAEvC,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;YACpB,OAAO,IAAI,QAAQ,CAAC,qBAAqB,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAA;QAC7D,CAAC;QAED,+DAA+D;QAC/D,qCAAqC;QACrC,MAAM,EAAE,GAAG,GAAG,CAAC,gBAAgB,CAAC,UAAU,CAAC,MAAM,CAAC,CAAA;QAClD,MAAM,aAAa,GAAG,GAAG,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;QAElD,IAAI,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC;YACxC,MAAM,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;YACpD,IAAI,CAAC,aAAa,IAAI,aAAa,KAAK,WAAW,EAAE,CAAC;gBACpD,OAAO,IAAI,QAAQ,CAAC,4CAA4C,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAA;YACpF,CAAC;YAED,OAAO,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;QACrC,CAAC;QAED,OAAO,IAAI,QAAQ,CAAC,IAAI,EAAE;YACxB,MAAM,EAAE,GAAG;YACX,UAAU,EAAE,aAAa;YACzB,OAAO,EAAE;gBACP,cAAc,EAAE,YAAY;aAC7B;SACF,CAAC,CAAA;IACJ,CAAC;CACF,CAAA"}

package/dist/common/index.d.ts

@@ -1,2 +0,0 @@
-export * as WSMessage from './ws-message-types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/common/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/common/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,uBAAuB,CAAA"}