@skipruntime/helpers 0.0.1 → 0.0.3

package/src/rest.ts

@@ -1,23 +1,23 @@
-import type { TJSON, Entry, ReactiveResponse } from "@skipruntime/api";
-import { parseReactiveResponse } from "./utils.js";
+import type { Json, Entry } from "@skipruntime/api";
 
 export type Entrypoint = {
   host: string;
-  port: number;
+  streaming_port: number;
+  control_port: number;
   secured?: boolean;
 };
 
 function toHttp(entrypoint: Entrypoint) {
   if (entrypoint.secured)
-    return `https://${entrypoint.host}:${entrypoint.port}`;
-  return `http://${entrypoint.host}:${entrypoint.port}`;
+    return `https://${entrypoint.host}:${entrypoint.control_port}`;
+  return `http://${entrypoint.host}:${entrypoint.control_port}`;
 }
 
 export async function fetchJSON<V>(
   url: string,
   method: "POST" | "GET" | "PUT" | "PATCH" | "HEAD" | "DELETE" = "GET",
-  headers: Record<string, string> = {},
-  data?: TJSON,
+  headers: { [header: string]: string } = {},
+  data?: Json,
 ): Promise<[V | null, Headers]> {
   const body = data ? JSON.stringify(data) : undefined;
   const response = await fetch(url, {
@@ -41,122 +41,66 @@ export async function fetchJSON<V>(
   return [responseJSON, response.headers];
 }
 
-export class SkipRESTService {
+export class RESTWrapperOfSkipService {
   private entrypoint: string;
 
   constructor(
     entrypoint: Entrypoint = {
       host: "localhost",
-      port: 3587,
+      streaming_port: 8080,
+      control_port: 8081,
     },
   ) {
     this.entrypoint = toHttp(entrypoint);
   }
 
-  async getAll<K extends TJSON, V extends TJSON>(
+  async getAll<K extends Json, V extends Json>(
     resource: string,
-    params: Record<string, string>,
-    reactiveAuth?: Uint8Array | string,
-  ): Promise<{ values: Entry<K, V>[]; reactive?: ReactiveResponse }> {
+    params: { [param: string]: string },
+  ): Promise<Entry<K, V>[]> {
     const qParams = new URLSearchParams(params).toString();
-    let header = {};
-    if (reactiveAuth) {
-      if (typeof reactiveAuth == "string") {
-        header = {
-          "X-Reactive-Auth": reactiveAuth,
-        };
-      } else {
-        header = {
-          "X-Reactive-Auth": Buffer.from(reactiveAuth.buffer).toString(
-            "base64",
-          ),
-        };
-      }
-    }
-    const [optValues, headers] = await fetchJSON<Entry<K, V>[]>(
-      `${this.entrypoint}/v1/${resource}?${qParams}`,
+    const [optValues, _headers] = await fetchJSON<Entry<K, V>[]>(
+      `${this.entrypoint}/v1/resources/${resource}?${qParams}`,
       "GET",
-      header,
     );
-    const reactive = parseReactiveResponse(headers);
     const values = optValues ?? [];
-    return reactive ? { values, reactive } : { values };
+    return values;
   }
 
-  async head(
+  async getArray<V extends Json>(
     resource: string,
-    params: Record<string, string>,
-    reactiveAuth: Uint8Array | string,
-  ): Promise<ReactiveResponse> {
-    const qParams = new URLSearchParams(params).toString();
-    const header = this.header(reactiveAuth);
-    const [_data, headers] = await fetchJSON(
-      `${this.entrypoint}/v1/${resource}?${qParams}`,
-      "HEAD",
-      header,
-    );
-    const reactiveResponse = parseReactiveResponse(headers);
-    if (!reactiveResponse)
-      throw new Error("Reactive response must be suplied.");
-    else {
-      return reactiveResponse;
-    }
-  }
-
-  async getArray<V extends TJSON>(
-    resource: string,
-    params: Record<string, string>,
+    params: { [param: string]: string },
     key: string,
-    reactiveAuth?: Uint8Array | string,
   ): Promise<V[]> {
     const qParams = new URLSearchParams(params).toString();
-    const header = this.header(reactiveAuth);
     const [data, _headers] = await fetchJSON<V[]>(
-      `${this.entrypoint}/v1/${resource}/${key}?${qParams}`,
+      `${this.entrypoint}/v1/resources/${resource}/${key}?${qParams}`,
       "GET",
-      header,
     );
     return data ?? [];
   }
 
-  async put<V extends TJSON>(
+  async put<K extends Json, V extends Json>(
     collection: string,
-    key: string,
+    key: K,
     value: V[],
   ): Promise<void> {
-    await fetchJSON(
-      `${this.entrypoint}/v1/${collection}/${key}`,
-      "PUT",
-      {},
-      value,
-    );
+    return await this.patch(collection, [[key, value]]);
   }
 
-  async patch<K extends TJSON, V extends TJSON>(
+  async patch<K extends Json, V extends Json>(
     collection: string,
     values: Entry<K, V>[],
   ): Promise<void> {
-    await fetchJSON(`${this.entrypoint}/v1/${collection}`, "PATCH", {}, values);
-  }
-
-  async deleteKey(collection: string, key: string): Promise<void> {
-    await fetchJSON(`${this.entrypoint}/v1/${collection}/${key}`, "DELETE", {});
+    await fetchJSON(
+      `${this.entrypoint}/v1/inputs/${collection}`,
+      "PATCH",
+      {},
+      values,
+    );
   }
 
-  private header(reactiveAuth?: Uint8Array | string): Record<string, string> {
-    if (reactiveAuth) {
-      if (typeof reactiveAuth == "string") {
-        return {
-          "X-Reactive-Auth": reactiveAuth,
-        };
-      } else {
-        return {
-          "X-Reactive-Auth": Buffer.from(reactiveAuth.buffer).toString(
-            "base64",
-          ),
-        };
-      }
-    }
-    return {};
+  async deleteKey<K extends Json>(collection: string, key: K): Promise<void> {
+    return await this.patch(collection, [[key, []]]);
   }
 }

package/src/utils.ts

@@ -1,78 +1,48 @@
-import type { Opt } from "@skip-wasm/std";
+import type { Nullable } from "@skip-wasm/std";
 import { ManyToOneMapper } from "@skipruntime/api";
-import type {
-  Accumulator,
-  NonEmptyIterator,
-  ReactiveResponse,
-  TJSON,
-} from "@skipruntime/api";
+import type { Reducer, NonEmptyIterator, Json } from "@skipruntime/api";
 
-export class Sum implements Accumulator<number, number> {
+export class Sum implements Reducer<number, number> {
   default = 0;
 
-  accumulate(acc: number, value: number): number {
+  add(acc: number, value: number): number {
     return acc + value;
   }
 
-  dismiss(acc: number, value: number): Opt<number> {
+  remove(acc: number, value: number): Nullable<number> {
     return acc - value;
   }
 }
 
-export class Min implements Accumulator<number, number> {
+export class Min implements Reducer<number, number> {
   default = null;
 
-  accumulate(acc: Opt<number>, value: number): number {
+  add(acc: Nullable<number>, value: number): number {
     return acc === null ? value : Math.min(acc, value);
   }
 
-  dismiss(acc: number, value: number): Opt<number> {
+  remove(acc: number, value: number): Nullable<number> {
     return value > acc ? acc : null;
   }
 }
 
-export class Max implements Accumulator<number, number> {
+export class Max implements Reducer<number, number> {
   default = null;
 
-  accumulate(acc: Opt<number>, value: number): number {
+  add(acc: Nullable<number>, value: number): number {
     return acc === null ? value : Math.max(acc, value);
   }
 
-  dismiss(acc: number, value: number): Opt<number> {
+  remove(acc: number, value: number): Nullable<number> {
     return value < acc ? acc : null;
   }
 }
 
 export class CountMapper<
-  K extends TJSON,
-  V extends TJSON,
+  K extends Json,
+  V extends Json,
 > extends ManyToOneMapper<K, V, number> {
   mapValues(values: NonEmptyIterator<V>): number {
     return values.toArray().length;
   }
 }
-
-export function parseReactiveResponse(
-  header: Headers | string,
-): ReactiveResponse | undefined {
-  const strReactiveResponse =
-    typeof header == "string"
-      ? header
-      : header.get("Skip-Reactive-Response-Token");
-  if (!strReactiveResponse) return undefined;
-  return JSON.parse(strReactiveResponse, (key: string, value: string) => {
-    if (key == "watermark") return BigInt(value);
-    return value;
-  }) as ReactiveResponse;
-}
-
-export function reactiveResponseHeader(
-  reactiveResponse: ReactiveResponse,
-): [string, string] {
-  return [
-    "Skip-Reactive-Response-Token",
-    JSON.stringify(reactiveResponse, (_key: string, value: unknown) =>
-      typeof value === "bigint" ? value.toString() : value,
-    ),
-  ];
-}