@arcote.tech/arc-host 0.1.0

package/dist/sqliteAdapter.d.ts

@@ -0,0 +1,3 @@
+import { type DBAdapterFactory } from "@arcote.tech/arc";
+export declare const sqliteAdapterFactory: (dbName: string) => DBAdapterFactory;
+//# sourceMappingURL=sqliteAdapter.d.ts.map

package/dist/sqliteAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqliteAdapter.d.ts","sourceRoot":"","sources":["../sqliteAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,gBAAgB,EAEtB,MAAM,kBAAkB,CAAC;AAoB1B,eAAO,MAAM,oBAAoB,WAAY,MAAM,KAAG,gBAMrD,CAAC"}

package/host.ts

@@ -0,0 +1,268 @@
+import {
+  ArcCollection,
+  MasterDataStorage,
+  QueryBuilderContext,
+  QueryCache,
+  type ArcCollectionAny,
+  type ArcContextAny,
+  type DatabaseAdapter,
+  type DataStorageChanges,
+  type MessageClientToHost,
+  type MessageHostToClient,
+  type RealTimeCommunicationAdapter,
+} from "@arcote.tech/arc";
+import type { Server, ServerWebSocket } from "bun";
+import jwt from "jsonwebtoken";
+
+class RTCHost implements RealTimeCommunicationAdapter {
+  private server!: Server;
+  private dataStore: MasterDataStorage;
+
+  constructor(
+    private context: ArcContextAny,
+    dbAdapter: Promise<DatabaseAdapter>,
+  ) {
+    this.dataStore = new MasterDataStorage(dbAdapter, () => this, context);
+    this.setupServer();
+  }
+
+  commitChanges(changes: DataStorageChanges[]): void {
+    // throw new Error("Method not implemented.");
+  }
+
+  async sync(
+    progressCallback: ({
+      store,
+      size,
+    }: {
+      store: string;
+      size: number;
+    }) => void,
+  ): Promise<void> {
+    // throw new Error("Method not implemented.");
+  }
+
+  private async verifyToken(token: string) {
+    try {
+      const secret = process.env.AUTH_SECRET as string;
+      if (!secret) {
+        throw new Error("AUTH_SECRET is not set");
+      }
+      const payload = jwt.verify(token, secret);
+      return payload;
+    } catch (error) {
+      console.error("Token verification failed:", error);
+      return null;
+    }
+  }
+
+  private async handleCommand(req: Request) {
+    const url = new URL(req.url);
+    const commandName = url.pathname.split("/command/")[1];
+
+    if (!commandName) {
+      return new Response("Command not specified", { status: 400 });
+    }
+    try {
+      const argument = await req.json();
+      // Create command context and execute command
+      const queryContext = new QueryBuilderContext(
+        new QueryCache(),
+        this.dataStore,
+      );
+      const commands = this.context.commandsClient(
+        "server",
+        queryContext,
+        this.dataStore,
+        (error) => console.error("Command error:", error),
+      );
+
+      const result = await (commands as any)[commandName](argument);
+      return new Response(JSON.stringify(result), {
+        headers: { "Content-Type": "application/json" },
+        status: 200,
+      });
+    } catch (error) {
+      console.error(`Error executing command ${commandName}:`, error);
+      return new Response("Internal Server Error", { status: 500 });
+    }
+  }
+
+  private async handleQuery(req: Request) {
+    try {
+      const body = await req.json();
+      const { query } = body;
+
+      if (!query || !query.element || !query.queryType) {
+        return new Response("Invalid query format", { status: 400 });
+      }
+
+      const { element, queryType, params } = query;
+
+      // Access the model and run the query
+      const queryBuilder = this.context.queryBuilder(
+        new QueryBuilderContext(new QueryCache(), this.dataStore),
+      ) as any;
+
+      // Get the appropriate element from the queryBuilder
+      const elementBuilder = queryBuilder[element];
+      if (!elementBuilder) {
+        return new Response(`Element '${element}' not found`, { status: 400 });
+      }
+
+      // Get the query method from the element
+      const queryMethod = elementBuilder[queryType];
+      if (!queryMethod || typeof queryMethod !== "function") {
+        return new Response(
+          `Query type '${queryType}' not found on element '${element}'`,
+          { status: 400 },
+        );
+      }
+
+      // Build and execute the query
+      const queryParams = params || [];
+      const queryObj = queryMethod.apply(elementBuilder, queryParams).toQuery();
+      const result = await queryObj.run(this.dataStore);
+
+      return new Response(JSON.stringify(result), {
+        headers: { "Content-Type": "application/json" },
+        status: 200,
+      });
+    } catch (error) {
+      console.error("Error executing query:", error);
+      return new Response(`Internal Server Error: ${error}`, {
+        status: 500,
+      });
+    }
+  }
+
+  private setupServer() {
+    this.server = Bun.serve({
+      fetch: async (req, server) => {
+        const url = new URL(req.url);
+
+        // const authHeader = req.headers.get("Authorization");
+        // const token =
+        //   authHeader?.replace("Bearer ", "") || url.searchParams.get("token");
+        // console.log(url);
+
+        // if (!token) {
+        //   return new Response("Unauthorized", { status: 401 });
+        // }
+
+        // const payload = await this.verifyToken(token);
+        // if (!payload) {
+        //   return new Response("Invalid token", { status: 401 });
+        // }
+        const payload = null;
+
+        // Handle different endpoints
+        if (
+          url.pathname === "/ws" &&
+          req.headers.get("Upgrade") === "websocket"
+        ) {
+          if (server.upgrade(req, { data: { user: payload } })) {
+            return;
+          }
+          return new Response("Upgrade failed", { status: 500 });
+        }
+
+        if (url.pathname === "/sync" && req.method === "GET") {
+          return await this.handleSync(url.searchParams.get("lastSync"));
+        }
+
+        if (url.pathname.startsWith("/command/") && req.method === "POST") {
+          return await this.handleCommand(req);
+        }
+        console.log(url.pathname);
+
+        if (url.pathname === "/query" && req.method === "POST") {
+          return await this.handleQuery(req);
+        }
+
+        return new Response("Not Found", { status: 404 });
+      },
+      websocket: {
+        message: this.onMessage.bind(this),
+        open(ws) {
+          ws.subscribe("sync");
+        },
+        close(ws, code, message) {},
+        perMessageDeflate: true,
+        backpressureLimit: 16 * 1024 * 1024,
+      },
+      port: 5005,
+    });
+  }
+
+  private async handleSync(lastDate: string | null) {
+    const syncDate = new Date();
+    const where = lastDate
+      ? {
+          lastUpdate: {
+            $gt: new Date(lastDate),
+          },
+        }
+      : {};
+
+    // const client = await this.clientPromise;
+    const syncResults: { store: string; items: any[] }[] = [];
+
+    for (const collection of this.context.elements
+      .filter(
+        (element) => element instanceof ArcCollection,
+        // || element instanceof ArcIndexedCollection,
+      )
+      .concat([{ name: "state" } as unknown as ArcCollectionAny])) {
+      // const result = await client
+      //   .db(process.env.MONGODB_DB)
+      //   .collection(collection.name)
+      //   .find(where)
+      //   .toArray();
+      // const prepareDeleted = result.map((item) => {
+      //   if (item.deleted) return { _id: item._id, deleted: true };
+      //   return item;
+      // });
+      // syncResults.push({
+      //   store: collection.name,
+      //   items: prepareDeleted,
+      // });
+    }
+
+    return new Response(
+      JSON.stringify({
+        results: syncResults,
+        syncDate: syncDate.toISOString(),
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+        },
+      },
+    );
+  }
+
+  private async onMessage(ws: ServerWebSocket, messageAsString: string) {
+    const message = JSON.parse(messageAsString) as MessageClientToHost;
+    switch (message.type) {
+      case "changes-executed":
+        await this.dataStore.applyChanges(message.changes);
+        this.publishMessage(ws, {
+          type: "state-changes",
+          changes: message.changes,
+        });
+        break;
+      default:
+        console.warn(`Message unsupported`, message);
+    }
+  }
+
+  private publishMessage(ws: ServerWebSocket, message: MessageHostToClient) {
+    ws.publish("sync", JSON.stringify(message));
+  }
+}
+
+export const rtcHostFactory =
+  (context: ArcContextAny, dbAdapter: Promise<DatabaseAdapter>) => () => {
+    return new RTCHost(context, dbAdapter);
+  };

package/index.ts

@@ -0,0 +1,11 @@
+import { type ArcContextAny } from "@arcote.tech/arc";
+import { rtcHostFactory } from "./host";
+import { sqliteAdapterFactory } from "./sqliteAdapter";
+
+export function hostLiveModel<C extends ArcContextAny>(
+  context: C,
+  options: { db: string; version: number },
+) {
+  const dbAdapterFactory = sqliteAdapterFactory(options.db);
+  rtcHostFactory(context, dbAdapterFactory(context))();
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@arcote.tech/arc-host",
+  "module": "index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "version": "0.1.0",
+  "private": false,
+  "author": "Przemysław Krasiński [arcote.tech]",
+  "dependencies": {
+    "@arcote.tech/arc": "workspace:*",
+    "jsonwebtoken": "^9.0.2"
+  },
+  "scripts": {
+    "build": "rm -rf dist && bun build ./index.ts --target=bun --outdir=dist && bun run build:declaration",
+    "build:declaration": "tsc --emitDeclarationOnly --declarationMap --project tsconfig.types.json",
+    "postbuild": "rimraf tsconfig.types.tsbuildinfo",
+    "type-check": "tsc",
+    "dev": "nodemon --ignore dist -e ts,tsx --exec 'bun run build'"
+  },
+  "devDependencies": {
+    "@types/jsonwebtoken": "^9.0.7"
+  }
+}

package/sqliteAdapter.ts

@@ -0,0 +1,32 @@
+import {
+  createSQLiteAdapterFactory,
+  type ArcContextAny,
+  type DBAdapterFactory,
+  type SQLiteDatabase,
+} from "@arcote.tech/arc";
+import { Database } from "bun:sqlite";
+
+class BunSQLiteDatabase implements SQLiteDatabase {
+  constructor(private db: Database) {}
+
+  async exec(sql: string, params?: any[]): Promise<any> {
+    try {
+      if (params && params.length > 0) {
+        const stmt = this.db.prepare(sql);
+        return stmt.all(...params);
+      }
+      return this.db.query(sql).all();
+    } catch (error) {
+      console.error("SQLite error:", error);
+      throw error;
+    }
+  }
+}
+
+export const sqliteAdapterFactory = (dbName: string): DBAdapterFactory => {
+  return async (context: ArcContextAny) => {
+    const db = new Database(dbName);
+    const sqliteDb = new BunSQLiteDatabase(db);
+    return createSQLiteAdapterFactory(sqliteDb)(context);
+  };
+};

package/tsconfig.types.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "jsx": "react-jsxdev",
+    "noEmit": false,
+    "emitDeclarationOnly": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./",
+    "skipLibCheck": true,
+    "composite": true,
+    "preserveSymlinks": true
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["./build.ts", "node_modules", "dist"]
+}