@peerbit/server 5.4.1 → 5.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@peerbit/server",
-	"version": "5.4.1",
+	"version": "5.4.2",
 	"author": "dao.xyz",
 	"repository": {
 		"type": "git",

package/src/cli.ts

@@ -999,10 +999,23 @@ export const cli = async (args?: string[]) => {
 												handler: async (args) => {
 													for (const api of apis) {
 														const list = await api.api.program.list();
-														api.log(`Running programs (${list.length}):`);
-														list.forEach((p) => {
-															api.log(chalk.green(p));
-														});
+														api.log(
+															`Running programs (${[...Object.keys(list)].length}):`,
+														);
+														for (const key of Object.keys(list)) {
+															let programOpenArgs = list[key];
+															let argsString = "";
+															if (
+																programOpenArgs &&
+																Object.keys(programOpenArgs).length > 0
+															) {
+																// show but indent
+																argsString =
+																	"  " + JSON.stringify(programOpenArgs);
+															}
+
+															api.log(chalk.green(key + argsString));
+														}
 													}
 												},
 											})

package/src/client.ts

@@ -225,13 +225,13 @@ export const createClient = async (
 				await Promise.all(resp.data.map((address: string) => drop(address)));
 			},
 
-			list: async (): Promise<string[]> => {
+			list: async (): Promise<Record<string, Record<string, any> | null>> => {
 				const resp = throwIfNot200(
 					await axiosInstance.get(endpoint + PROGRAMS_PATH, {
 						validateStatus,
 					}),
 				);
-				return resp.data as string[];
+				return resp.data as Record<string, Record<string, any> | null>;
 			},
 			variants: async (): Promise<string[]> => {
 				const resp = throwIfNot200(

package/src/server.ts

@@ -39,7 +39,7 @@ import {
 	TRUST_PATH,
 	VERSIONS_PATH,
 } from "./routes.js";
-import { Session } from "./session.js";
+import { JSONArgs, Session } from "./session.js";
 import { getBody, verifyRequest } from "./signed-request.js";
 import { Trust } from "./trust.js";
 import type {
@@ -154,10 +154,13 @@ export const startServerWithNode = async (properties: {
 		for (const [string] of await session.imports.all()) {
 			await import(string);
 		}
-		for (const [address] of await session.programs.all()) {
+		for (const [address, args] of await session.programs.all()) {
 			// TODO args
 			try {
-				await peer.open(address, { timeout: 3000 });
+				await peer.open<any>(address, {
+					args: args?.length > 0 ? JSONArgs.from(args) : undefined,
+					timeout: 1e4,
+				});
 			} catch (error) {
 				console.error(error);
 			}
@@ -365,10 +368,19 @@ export const startApiServer = async (
 								try {
 									const ref: any =
 										(client as Peerbit).handler?.items?.keys() || [];
-									const keys = JSON.stringify([...ref]);
+									let args: Record<string, Record<string, any> | null> = {};
+									for (const key of ref) {
+										const argsBytes =
+											await properties.session?.programs.get(key);
+										if (argsBytes && argsBytes.length > 0) {
+											args[key] = JSONArgs.from(argsBytes).args;
+										} else {
+											args[key] = null;
+										}
+									}
 									res.setHeader("Content-Type", "application/json");
 									res.writeHead(200);
-									res.end(keys);
+									res.end(JSON.stringify(args));
 								} catch (error: any) {
 									res.writeHead(404);
 									res.end(error.message);
@@ -489,18 +501,19 @@ export const startApiServer = async (
 											Program,
 										);
 									}
+									let extraArgsParsed =
+										Object.keys(extraArgs).length > 0 ? extraArgs : undefined;
 									client
 										.open(program, {
-											args:
-												Object.keys(extraArgs).length > 0
-													? extraArgs
-													: undefined,
+											args: extraArgsParsed,
 										})
 										.then(async (program) => {
 											// TODO what if this is a reopen?
 											await properties?.session?.programs.add(
 												program.address,
-												new Uint8Array(),
+												extraArgsParsed
+													? new JSONArgs(extraArgsParsed).bytes
+													: new Uint8Array(),
 											);
 											res.writeHead(200);
 											res.end(program.address.toString());

package/src/session.ts

@@ -1,3 +1,4 @@
+import { deserialize, field, serialize, variant } from "@dao-xyz/borsh";
 import type { AbstractLevel } from "abstract-level";
 
 export class Session {
@@ -30,6 +31,47 @@ export class Session {
 	}
 }
 
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+@variant(0)
+export class JSONArgs {
+	@field({ type: Uint8Array })
+	private _args: Uint8Array;
+
+	cache: Record<string, any> | undefined;
+	constructor(
+		args: Record<
+			string,
+			string | number | bigint | Uint8Array | boolean | null | undefined
+		>,
+	) {
+		this.cache = args;
+		this._args = this.encode(args);
+	}
+	private encode(obj: any): Uint8Array {
+		return new Uint8Array(encoder.encode(JSON.stringify(obj)));
+	}
+
+	private decode(bytes: Uint8Array) {
+		return (this.cache = JSON.parse(decoder.decode(bytes).toString()));
+	}
+
+	get args(): Record<
+		string,
+		string | number | bigint | Uint8Array | boolean | null | undefined
+	> {
+		return this.cache || this.decode(this._args);
+	}
+
+	get bytes(): Uint8Array {
+		return serialize(this);
+	}
+
+	static from(bytes: Uint8Array): JSONArgs {
+		return deserialize(bytes, JSONArgs);
+	}
+}
 export class KV {
 	constructor(
 		readonly level: AbstractLevel<
@@ -39,6 +81,9 @@ export class KV {
 		>,
 	) {}
 
+	get(key: string): Promise<Uint8Array | undefined> {
+		return this.level.get(key);
+	}
 	add(key: string, arg: Uint8Array) {
 		return this.level.put(key, arg);
 	}