@arcote.tech/arc-host 0.1.10 → 0.3.0

package/host.ts

@@ -1,510 +0,0 @@
-import {
-  MasterDataStorage,
-  Model,
-  QueryBuilderContext,
-  QueryCache,
-  type ArcContextAny,
-  type AuthContext,
-  type DatabaseAdapter,
-  type DataStorageChanges,
-  type MessageClientToHost,
-  type MessageHostToClient,
-  type RealTimeCommunicationAdapter,
-} from "@arcote.tech/arc";
-import type { Server, ServerWebSocket } from "bun";
-import { verifyToken, type TokenPayload } from "./auth/jwt";
-
-class RTCHost implements RealTimeCommunicationAdapter {
-  private server!: Server;
-  private dataStore: MasterDataStorage;
-  private model: Model<ArcContextAny>;
-
-  constructor(
-    private context: ArcContextAny,
-    dbAdapter: Promise<DatabaseAdapter>,
-  ) {
-    this.dataStore = new MasterDataStorage(dbAdapter, () => this, context);
-    this.model = new Model(context, this.dataStore, (error) =>
-      console.error("Command error:", error),
-    );
-    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 verifyAuthToken(token: string) {
-    try {
-      const payload = verifyToken(token);
-      return payload;
-    } catch (error) {
-      return null;
-    }
-  }
-
-  /**
-   * Convert JWT payload to AuthContext
-   */
-  private tokenToAuthContext(
-    payload: TokenPayload,
-    ipAddress?: string,
-  ): AuthContext {
-    return {
-      userId: payload.userId,
-      ipAddress,
-    } as AuthContext;
-  }
-
-  /**
-   * Extract client IP address from request headers
-   */
-  private getClientIpAddress(req: Request): string | undefined {
-    // Check common headers for client IP
-    const xForwardedFor = req.headers.get("x-forwarded-for");
-    const xRealIp = req.headers.get("x-real-ip");
-    const cfConnectingIp = req.headers.get("cf-connecting-ip");
-
-    if (xForwardedFor) {
-      // x-forwarded-for can contain multiple IPs, take the first one
-      return xForwardedFor.split(",")[0].trim();
-    }
-
-    if (xRealIp) {
-      return xRealIp;
-    }
-
-    if (cfConnectingIp) {
-      return cfConnectingIp;
-    }
-
-    // Fallback - this might not work in all environments
-    return undefined;
-  }
-
-  /**
-   * Get default auth context for anonymous users
-   */
-  private getDefaultAuthContext(ipAddress?: string): AuthContext {
-    return {
-      ipAddress,
-    };
-  }
-
-  /**
-   * Parse FormData back to an object structure
-   */
-  private async parseFormDataToObject(formData: FormData): Promise<any> {
-    const obj: any = {};
-
-    // Use forEach instead of entries() for better TypeScript compatibility
-    formData.forEach((value, key) => {
-      this.setNestedProperty(obj, key, value);
-    });
-
-    return obj;
-  }
-
-  /**
-   * Helper method to set nested properties from FormData keys like "user[profile][avatar]"
-   */
-  private setNestedProperty(obj: any, path: string, value: any): void {
-    // Handle array notation like "items[0]" or nested object notation like "user[profile][name]"
-    const keys = path.split(/[\[\]]+/).filter((key) => key !== "");
-    let current = obj;
-
-    for (let i = 0; i < keys.length - 1; i++) {
-      const key = keys[i];
-      const nextKey = keys[i + 1];
-
-      // Check if next key is a number (array index)
-      if (!isNaN(Number(nextKey))) {
-        if (!current[key]) {
-          current[key] = [];
-        }
-        if (!current[key][Number(nextKey)]) {
-          current[key][Number(nextKey)] = {};
-        }
-        current = current[key][Number(nextKey)];
-        i++; // Skip the array index
-      } else {
-        if (!current[key]) {
-          current[key] = {};
-        }
-        current = current[key];
-      }
-    }
-
-    const finalKey = keys[keys.length - 1];
-    if (!isNaN(Number(finalKey))) {
-      // This is an array index at the root level
-      const parentKey = keys[keys.length - 2];
-      if (!current[parentKey]) {
-        current[parentKey] = [];
-      }
-      current[parentKey][Number(finalKey)] = value;
-    } else {
-      current[finalKey] = value;
-    }
-  }
-
-  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 {
-      // Extract token from Authorization header
-      const authHeader = req.headers.get("Authorization");
-      const token = authHeader?.replace("Bearer ", "");
-
-      const clientIp = this.getClientIpAddress(req);
-      let authContext: AuthContext;
-      if (token && !this.isPublicEndpoint(url.pathname)) {
-        const payload = await this.verifyAuthToken(token);
-        if (!payload) {
-          return new Response("Invalid or expired token", { status: 401 });
-        }
-        authContext = this.tokenToAuthContext(payload, clientIp);
-      } else {
-        authContext = this.getDefaultAuthContext(clientIp);
-      }
-
-      let argument: any;
-      const contentType = req.headers.get("Content-Type");
-
-      // Handle different content types
-      if (contentType && contentType.includes("multipart/form-data")) {
-        // Parse FormData
-        const formData = await req.formData();
-        argument = await this.parseFormDataToObject(formData);
-      } else {
-        // Parse JSON (default behavior)
-        argument = await req.json();
-      }
-
-      // Use the model's commands() method with auth context
-      const commands = this.model.commands(authContext);
-
-      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 {
-      // Extract token from Authorization header
-      const authHeader = req.headers.get("Authorization");
-      const token = authHeader?.replace("Bearer ", "");
-
-      const clientIp = this.getClientIpAddress(req);
-      let authContext: AuthContext;
-      if (token) {
-        const payload = await this.verifyAuthToken(token);
-        if (!payload) {
-          return new Response("Invalid or expired token", { status: 401 });
-        }
-        authContext = this.tokenToAuthContext(payload, clientIp);
-      } else {
-        return new Response("Authorization token required", { status: 401 });
-      }
-
-      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 with auth context
-      const queryBuilder = this.context.queryBuilder(
-        new QueryBuilderContext(new QueryCache(), this.dataStore),
-        authContext,
-      ) 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 async handleRoute(req: Request) {
-    const url = new URL(req.url);
-    const method = req.method;
-
-    // Find matching route
-    let matchedRoute: any = null;
-    let routeParams: Record<string, string> = {};
-
-    for (const element of this.context.elements) {
-      // Check if element has matchesRoutePath method (ArcRoute)
-      if (typeof (element as any).matchesRoutePath === "function") {
-        const { matches, params } = (element as any).matchesRoutePath(
-          url.pathname,
-        );
-        if (matches) {
-          matchedRoute = element;
-          routeParams = params || {};
-          break;
-        }
-      }
-    }
-
-    if (!matchedRoute) {
-      return new Response("Route not found", { status: 404 });
-    }
-
-    const handler = matchedRoute.getHandler(method);
-    if (!handler) {
-      return new Response(`Method ${method} not allowed`, { status: 405 });
-    }
-
-    try {
-      // Extract token from Authorization header
-      const authHeader = req.headers.get("Authorization");
-      const token = authHeader?.replace("Bearer ", "");
-
-      const clientIp = this.getClientIpAddress(req);
-      let authContext: AuthContext;
-
-      if (token && !matchedRoute.isPublic) {
-        const payload = await this.verifyAuthToken(token);
-        if (!payload) {
-          return new Response("Invalid or expired token", { status: 401 });
-        }
-        authContext = this.tokenToAuthContext(payload, clientIp);
-      } else {
-        authContext = this.getDefaultAuthContext(clientIp);
-      }
-
-      // Use the model's routes method to properly handle event publishing
-      const routes = this.model.routes(authContext);
-      const response = await routes[matchedRoute.name](
-        method,
-        req,
-        routeParams,
-        url,
-      );
-      return response;
-    } catch (error) {
-      console.error(`Error executing route ${matchedRoute.name}:`, error);
-      return new Response("Internal Server Error", { status: 500 });
-    }
-  }
-
-  private setupServer() {
-    this.server = Bun.serve({
-      fetch: async (req, server) => {
-        const url = new URL(req.url);
-
-        // Extract token from Authorization header or query parameter
-        const authHeader = req.headers.get("Authorization");
-        const token =
-          authHeader?.replace("Bearer ", "") || url.searchParams.get("token");
-
-        // Verify token for protected endpoints
-        let payload = null;
-        if (token) {
-          payload = await this.verifyAuthToken(token);
-
-          // For protected endpoints, require valid token
-          if (!payload && !this.isPublicEndpoint(url.pathname)) {
-            return new Response("Invalid or expired token", { status: 401 });
-          }
-        } else if (!this.isPublicEndpoint(url.pathname)) {
-          return new Response("Authorization token required", { status: 401 });
-        }
-
-        // 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);
-        }
-
-        if (url.pathname === "/query" && req.method === "POST") {
-          return await this.handleQuery(req);
-        }
-
-        // Try to handle as a route
-        const routeResponse = await this.handleRoute(req);
-        if (routeResponse.status !== 404) {
-          return routeResponse;
-        }
-
-        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,
-      idleTimeout: 30,
-    });
-  }
-
-  private isPublicEndpoint(pathname: string): boolean {
-    // Iterate through all context elements and check if any match and are public
-    for (const element of this.context.elements) {
-      // Check if element has matchesCommandPath method (ArcCommand)
-      if (typeof (element as any).matchesCommandPath === "function") {
-        const { matches, isPublic } = (element as any).matchesCommandPath(
-          pathname,
-        );
-        if (matches) {
-          return isPublic;
-        }
-      }
-
-      // Check if element has matchesRoutePath method (ArcRoute)
-      if (typeof (element as any).matchesRoutePath === "function") {
-        const { matches, isPublic } = (element as any).matchesRoutePath(
-          pathname,
-        );
-        if (matches) {
-          return isPublic;
-        }
-      }
-    }
-
-    // Default to non-public if no matching element found
-    return false;
-  }
-
-  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/postgresAdapter.ts

@@ -1,50 +0,0 @@
-import {
-  createPostgreSQLAdapterFactory,
-  type ArcContextAny,
-  type DBAdapterFactory,
-  type PostgreSQLDatabase,
-} from "@arcote.tech/arc";
-import { SQL } from "bun";
-
-class BunPostgreSQLDatabase implements PostgreSQLDatabase {
-  private connectionString: string;
-  private sql: SQL;
-  constructor(connectionString: string) {
-    this.connectionString = connectionString;
-    this.sql = new SQL(this.connectionString);
-  }
-
-  async exec(query: string, params?: any[]): Promise<any> {
-    try {
-      const result = await this.sql.unsafe(query, params);
-      return result;
-    } catch (error) {
-      console.error("PostgreSQL error:", error, query, params);
-      throw error;
-    }
-  }
-
-  async execBatch(
-    queries: Array<{ sql: string; params?: any[] }>,
-  ): Promise<any> {
-    try {
-      return await this.sql.transaction(async (tx) => {
-        for (const query of queries) {
-          await tx.unsafe(query.sql, query.params);
-        }
-      });
-    } catch (error) {
-      console.error("PostgreSQL batch transaction error:", error);
-      throw error;
-    }
-  }
-}
-
-export const postgreSQLAdapterFactory = (
-  connectionString: string,
-): DBAdapterFactory => {
-  return async (context: ArcContextAny) => {
-    const pgDb = new BunPostgreSQLDatabase(connectionString);
-    return createPostgreSQLAdapterFactory(pgDb)(context);
-  };
-};