push and generate token server

Author: SandroMaglione

apps/client/src/workers/sync.ts

@@ -1,6 +1,7 @@
 import { WorkerRunner } from "@effect/platform";
 import { BrowserWorkerRunner } from "@effect/platform-browser";
 import { Effect, Layer } from "effect";
+import { LoroDoc } from "loro-crdt";
 import { ApiClient } from "../lib/api-client";
 import { Dexie } from "../lib/dexie";
 import { RuntimeClient } from "../lib/runtime-client";
@@ -66,12 +67,15 @@ const WorkerLive = WorkerRunner.layerSerialized(WorkerMessage, {
           )
         );
 
+        const doc = new LoroDoc();
+        doc.import(response.snapshot);
+
         yield* manager
           .put({
             workspaceId: response.workspaceId,
             snapshot: response.snapshot,
             token: response.token,
-            version: new Uint8Array(), // TODO
+            version: doc.version().encode(),
           })
           .pipe(Effect.mapError(() => "Put workspace error"));
 

apps/server/.env.example

@@ -2,4 +2,5 @@ POSTGRES_PASSWORD=postgres
 POSTGRES_USERNAME=postgres
 POSTGRES_DATABASE=postgres
 POSTGRES_HOST=localhost
-POSTGRES_PORT=5435
+POSTGRES_PORT=5435
+JWT_SECRET=

apps/server/package.json

@@ -12,6 +12,7 @@
   "author": "",
   "license": "ISC",
   "devDependencies": {
+    "@types/jsonwebtoken": "^9.0.9",
     "@types/node": "^22.5.1",
     "drizzle-kit": "^0.30.4",
     "tsx": "^4.19.2"
@@ -24,6 +25,7 @@
     "@local/sync": "workspace:*",
     "drizzle-orm": "^0.39.3",
     "effect": "^3.13.2",
+    "jsonwebtoken": "^9.0.2",
     "pg": "^8.13.3"
   }
 }

apps/server/src/group/sync-auth.ts

@@ -1,15 +1,45 @@
 import { HttpApiBuilder } from "@effect/platform";
-import { SyncApi } from "@local/sync";
-import { Effect } from "effect";
+import { SyncApi, type Scope } from "@local/sync";
+import { Config, Effect, Redacted } from "effect";
+import * as jwt from "jsonwebtoken";
+
+interface TokenPayload {
+  iat: number; // Issued at (Unix timestamp)
+  exp?: number; // Expiration (optional for master tokens)
+  sub: string; // Client ID
+  workspaceId: string; // Workshop ID
+  scope: typeof Scope.Type; // Permission scope
+  isMaster: boolean; // Master token flag
+}
 
 export const SyncAuthGroupLive = HttpApiBuilder.group(
   SyncApi,
   "syncAuth",
   (handlers) =>
     Effect.gen(function* () {
+      const secretKey = yield* Config.redacted("JWT_SECRET");
       return handlers
         .handle("generateToken", ({ payload }) =>
-          Effect.fail("Not implemented")
+          Effect.gen(function* () {
+            const tokenPayload = {
+              iat: Math.floor(Date.now() / 1000), // Current timestamp in seconds
+              sub: payload.clientId,
+              workspaceId: payload.workspaceId,
+              scope: "read_write", // TODO
+              isMaster: true, // TODO
+            } satisfies TokenPayload;
+
+            const token = jwt.sign(tokenPayload, Redacted.value(secretKey), {
+              algorithm: "HS256",
+            });
+
+            return {
+              token,
+              workspaceId: payload.workspaceId,
+              snapshot: payload.snapshot,
+              createdAt: new Date(),
+            };
+          })
         )
         .handle("issueToken", ({ path: { workspaceId } }) =>
           Effect.fail("Not implemented")

apps/server/src/group/sync-data.ts

@@ -1,6 +1,6 @@
 import { HttpApiBuilder } from "@effect/platform";
 import { SyncApi } from "@local/sync";
-import { LoroSchemaTransform } from "@local/sync/loro";
+import { SnapshotToLoroDoc } from "@local/sync/loro";
 import { and, eq } from "drizzle-orm";
 import { Array, Effect, Layer, Schema } from "effect";
 import { workspaceTable } from "../db/schema";
@@ -17,7 +17,7 @@ export const SyncDataGroupLive = HttpApiBuilder.group(
           "push",
           ({ payload: { clientId, snapshot }, path: { workspaceId } }) =>
             Effect.gen(function* () {
-              const doc = yield* Schema.encode(LoroSchemaTransform)(snapshot);
+              const doc = yield* Schema.decode(SnapshotToLoroDoc)(snapshot);
 
               const workspace = yield* query({
                 Request: Schema.Struct({
@@ -39,26 +39,29 @@ export const SyncDataGroupLive = HttpApiBuilder.group(
 
               doc.import(workspace.snapshot); // 🪄
 
-              const newSnapshot =
-                yield* Schema.decode(LoroSchemaTransform)(doc);
+              const newSnapshot = yield* Schema.encode(SnapshotToLoroDoc)(doc);
 
-              yield* query({
+              const newWorkspace = yield* query({
                 Request: Schema.Struct({
-                  newSnapshot: Schema.Uint8Array,
+                  newSnapshot: Schema.Uint8ArrayFromSelf,
                 }),
                 execute: (db, { newSnapshot: snapshot }) =>
-                  db.insert(workspaceTable).values({
-                    snapshot,
-                    clientId: workspace.clientId,
-                    workspaceId: workspace.workspaceId,
-                    ownerClientId: workspace.ownerClientId,
-                    // createdAt
-                  }),
-              })({ newSnapshot });
+                  db
+                    .insert(workspaceTable)
+                    .values({
+                      snapshot,
+                      clientId: workspace.clientId,
+                      workspaceId: workspace.workspaceId,
+                      ownerClientId: workspace.ownerClientId,
+                    })
+                    .returning(),
+              })({ newSnapshot }).pipe(Effect.flatMap(Array.head));
 
-              return yield* Effect.fail({
-                message: "Not (fully) implemented" as const,
-              });
+              return {
+                workspaceId: newWorkspace.workspaceId,
+                createdAt: newWorkspace.createdAt,
+                snapshot: newWorkspace.snapshot,
+              };
             }).pipe(Effect.mapError((error) => error.message))
         )
         .handle("pull", ({ path: { workspaceId } }) =>

packages/sync/src/loro.ts

@@ -43,26 +43,41 @@ const SnapshotSchemaTransform = Schema.instanceOf(LoroDoc<LoroSchema>).pipe(
 );
 
 export const Snapshot = Schema.Uint8Array;
-export const LoroSchemaTransform = Schema.instanceOf(LoroDoc<LoroSchema>).pipe(
-  Schema.transformOrFail(Snapshot, {
+export const SnapshotToLoroDoc = Schema.Uint8ArrayFromSelf.pipe(
+  Schema.transformOrFail(Schema.instanceOf(LoroDoc<LoroSchema>), {
     decode: (from, _, ast) =>
-      Schema.encode(Snapshot)(from.export({ mode: "snapshot" })).pipe(
+      Effect.gen(function* () {
+        const doc = new LoroDoc<LoroSchema>();
+        doc.import(from);
+
+        // TODO: This?
+        yield* Schema.decodeUnknown(SnapshotSchema)(doc.toJSON());
+
+        return doc;
+      }).pipe(
         Effect.mapError(
           (error) => new ParseResult.Type(ast, from, error.message)
         )
       ),
 
     encode: (to, _, ast) =>
-      Schema.decode(Snapshot)(to).pipe(
-        Effect.flatMap((data) =>
-          Effect.gen(function* () {
-            const doc = new LoroDoc<LoroSchema>();
-            doc.import(data);
-            yield* Schema.decodeUnknown(SnapshotSchema)(doc.toJSON());
-            return doc;
-          })
-        ),
+      Schema.encode(Snapshot)(to.export({ mode: "snapshot" })).pipe(
+        Effect.flatMap(Schema.decode(Snapshot)),
         Effect.mapError((error) => new ParseResult.Type(ast, to, error.message))
       ),
   })
 );
+
+// const swap = <A, I, R>(
+//   schema: Schema.Schema<A, I, R>
+// ): Schema.Schema<I, A, R> =>
+//   Schema.transformOrFail(
+//     Schema.typeSchema(schema),
+//     Schema.encodedSchema(schema),
+//     {
+//       decode: ParseResult.encode(schema),
+//       encode: ParseResult.decode(schema),
+//     }
+//   );
+
+// export const LoroDocSchema = Schema.compose( LoroSchemaTransform, Snapshot);

packages/sync/src/main.ts

@@ -5,7 +5,7 @@ import {
   HttpApiSchema,
 } from "@effect/platform";
 import { Schema } from "effect";
-import { LoroSchemaTransform } from "./loro";
+import { Snapshot } from "./loro";
 
 export const ClientId = Schema.UUID;
 export const WorkspaceId = Schema.UUID;
@@ -23,7 +23,7 @@ export class WorkspaceTable extends Schema.Class<WorkspaceTable>(
   ownerClientId: ClientId,
   createdAt: Schema.DateFromString,
   clientId: ClientId,
-  snapshot: LoroSchemaTransform,
+  snapshot: Snapshot,
 }) {}
 
 export class TokenTable extends Schema.Class<TokenTable>("TokenTable")({