@synnaxlabs/client 0.2.0 → 0.13.5

package/src/ontology/group/payload.ts

@@ -0,0 +1,65 @@
+// Copyright 2023 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { toArray } from "@synnaxlabs/x";
+import { z } from "zod";
+
+export const keyZ = z.string().uuid();
+export type Key = z.infer<typeof keyZ>;
+export type Name = string;
+export type Keys = Key[];
+export type Names = Name[];
+export type Params = Key | Name | Keys | Names;
+
+export const payloadZ = z.object({
+  key: keyZ,
+  name: z.string(),
+});
+
+export type Payload = z.infer<typeof payloadZ>;
+
+export type ParamAnalysisResult =
+  | {
+      single: true;
+      variant: "keys";
+      normalized: Keys;
+      actual: Key;
+    }
+  | {
+      single: true;
+      variant: "names";
+      normalized: Names;
+      actual: Name;
+    }
+  | {
+      single: false;
+      variant: "keys";
+      normalized: Keys;
+      actual: Keys;
+    }
+  | {
+      single: false;
+      variant: "names";
+      normalized: Names;
+      actual: Names;
+    };
+
+export const analyzeParams = (params: Params): ParamAnalysisResult => {
+  const normal = toArray(params) as Keys | Names;
+  if (normal.length === 0) {
+    throw new Error("No groups specified");
+  }
+  const isKey = keyZ.safeParse(normal[0]).success;
+  return {
+    single: !Array.isArray(params),
+    variant: isKey ? "keys" : "names",
+    normalized: normal,
+    actual: params,
+  } as const as ParamAnalysisResult;
+};

package/src/ontology/group/writer.ts

@@ -0,0 +1,48 @@
+// Copyright 2023 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { z } from "zod";
+
+import { type Payload, payloadZ } from "@/ontology/group/payload";
+import { type ID } from "@/ontology/payload";
+
+const resZ = z.object({
+  group: payloadZ,
+});
+
+export class Writer {
+  private static readonly ENDPOINT = "/ontology/create-group";
+  private static readonly ENDPOINT_RENAME = "/ontology/rename-group";
+  private static readonly ENDPOINT_DELETE = "/ontology/delete-group";
+  client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async create(parent: ID, name: string): Promise<Payload> {
+    const req = { parent, name };
+    const [res, err] = await this.client.send(Writer.ENDPOINT, req, resZ);
+    if (err != null) throw err;
+    return res.group;
+  }
+
+  async rename(key: string, name: string): Promise<void> {
+    const req = { key, name };
+    const [, err] = await this.client.send(Writer.ENDPOINT_RENAME, req, z.object({}));
+    if (err != null) throw err;
+  }
+
+  async delete(keys: string[]): Promise<void> {
+    const req = { keys };
+    const [, err] = await this.client.send(Writer.ENDPOINT_DELETE, req, z.object({}));
+    if (err != null) throw err;
+  }
+}

package/src/ontology/index.ts

@@ -0,0 +1,10 @@
+// Copyright 2023 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+export * as ontology from "@/ontology/external";

package/src/ontology/ontology.spec.ts

@@ -0,0 +1,114 @@
+// Copyright 2023 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { describe, expect, test, it } from "vitest";
+
+import { ontology } from "@/ontology";
+import { newClient } from "@/setupspecs";
+
+const client = newClient();
+
+const randomName = (): string => `group-${Math.random()}`;
+
+describe("Ontology", () => {
+  describe("retrieve", () => {
+    test("retrieve", async () => {
+      const name = randomName();
+      const g = await client.ontology.groups.create(ontology.Root, name);
+      const g2 = await client.ontology.retrieve(g.ontologyID);
+      expect(g2.name).toEqual(name);
+    });
+    test("retrieve children", async () => {
+      const name = randomName();
+      const g = await client.ontology.groups.create(ontology.Root, name);
+      const name2 = randomName();
+      await client.ontology.groups.create(g.ontologyID, name2);
+      const children = await client.ontology.retrieveChildren(g.ontologyID);
+      expect(children.length).toEqual(1);
+      expect(children[0].name).toEqual(name2);
+    });
+    test("retrieve parents", async () => {
+      const name = randomName();
+      const g = await client.ontology.groups.create(ontology.Root, name);
+      const name2 = randomName();
+      const g2 = await client.ontology.groups.create(g.ontologyID, name2);
+      const parents = await client.ontology.retrieveParents(g2.ontologyID);
+      expect(parents.length).toEqual(1);
+      expect(parents[0].name).toEqual(name);
+    });
+    test("add children", async () => {
+      const name = randomName();
+      const g = await client.ontology.groups.create(ontology.Root, name);
+      const name2 = randomName();
+      const g2 = await client.ontology.groups.create(ontology.Root, name2);
+      await client.ontology.addChildren(g.ontologyID, g2.ontologyID);
+      const children = await client.ontology.retrieveChildren(g.ontologyID);
+      expect(children.length).toEqual(1);
+      expect(children[0].name).toEqual(name2);
+    });
+    test("remove children", async () => {
+      const name = randomName();
+      const g = await client.ontology.groups.create(ontology.Root, name);
+      const name2 = randomName();
+      const g2 = await client.ontology.groups.create(ontology.Root, name2);
+      await client.ontology.addChildren(g.ontologyID, g2.ontologyID);
+      await client.ontology.removeChildren(g.ontologyID, g2.ontologyID);
+      const children = await client.ontology.retrieveChildren(g.ontologyID);
+      expect(children.length).toEqual(0);
+    });
+    test("move children", async () => {
+      const name = randomName();
+      const g = await client.ontology.groups.create(ontology.Root, name);
+      const name2 = randomName();
+      const g2 = await client.ontology.groups.create(ontology.Root, name2);
+      const oldRootLength = (await client.ontology.retrieveChildren(ontology.Root))
+        .length;
+      await client.ontology.moveChildren(ontology.Root, g.ontologyID, g2.ontologyID);
+      const children = await client.ontology.retrieveChildren(g.ontologyID);
+      expect(children.length).toEqual(1);
+      const newRootLength = (await client.ontology.retrieveChildren(ontology.Root))
+        .length;
+      expect(newRootLength).toEqual(oldRootLength - 1);
+    });
+  });
+  describe("cdc", async () => {
+    it("should correctly decode a set of relationships from a string", () => {
+      const rel = ontology.parseRelationship("typeA:keyA->parent->typeB:keyB");
+      expect(rel.type).toEqual("parent");
+      expect(rel.from.type).toEqual("typeA");
+      expect(rel.from.key).toEqual("keyA");
+      expect(rel.to.type).toEqual("typeB");
+      expect(rel.to.key).toEqual("keyB");
+    });
+    it("should correctly propagate resource changes to the ontology", async () => {
+      const change = await client.ontology.openChangeTracker();
+      const p = new Promise<ontology.ResourceChange[]>((resolve) => {
+        change.resources.onChange((changes) => {
+          resolve(changes);
+        });
+      });
+      await client.ontology.groups.create(ontology.Root, randomName());
+      const c = await p;
+      expect(c.length).toBeGreaterThan(0);
+      await change.close();
+    });
+    it("should correctly propagate relationship changes to the ontology", async () => {
+      const change = await client.ontology.openChangeTracker();
+      const p = new Promise<ontology.RelationshipChange[]>((resolve) => {
+        change.relationships.onChange((changes) => {
+          resolve(changes);
+        });
+      });
+      await client.ontology.groups.create(ontology.Root, randomName());
+      const c = await p;
+      expect(c.length).toBeGreaterThan(0);
+      await change.close();
+    });
+  });
+});

package/src/ontology/payload.ts

@@ -0,0 +1,121 @@
+// Copyright 2023 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { z } from "zod";
+
+const resourceTypeZ = z.union([
+  z.literal("builtin"),
+  z.literal("cluster"),
+  z.literal("channel"),
+  z.literal("node"),
+  z.literal("group"),
+  z.literal("range"),
+  z.literal("range-alias"),
+  z.literal("user"),
+  z.literal("workspace"),
+  z.literal("pid"),
+  z.literal("lineplot"),
+]);
+
+export type ResourceType = z.infer<typeof resourceTypeZ>;
+
+export const idZ = z.object({
+  type: resourceTypeZ,
+  key: z.string(),
+});
+
+export const stringIDZ = z.string().transform((v) => {
+  const [type, key] = v.split(":");
+  return {
+    type: type as ResourceType,
+    key,
+  };
+});
+
+export const crudeIDZ = z.union([stringIDZ, idZ]);
+
+export class ID {
+  type: ResourceType;
+  key: string;
+
+  constructor(args: z.input<typeof crudeIDZ> | ID) {
+    if (args instanceof ID) {
+      this.type = args.type;
+      this.key = args.key;
+    } else if (typeof args === "string") {
+      const [type, key] = args.split(":");
+      this.type = type as ResourceType;
+      this.key = key;
+    } else {
+      this.type = args.type;
+      this.key = args.key;
+    }
+  }
+
+  toString(): string {
+    return `${this.type}:${this.key}`;
+  }
+
+  get payload(): z.infer<typeof idZ> {
+    return {
+      type: this.type,
+      key: this.key,
+    };
+  }
+
+  static readonly z = z.union([crudeIDZ, z.instanceof(ID)]).transform((v) => new ID(v));
+}
+
+export const Root = new ID({ type: "builtin", key: "root" });
+
+export const schemaFieldZ = z.object({
+  type: z.number(),
+});
+
+export type SchemaField = z.infer<typeof schemaFieldZ>;
+
+export const schemaZ = z.object({
+  type: resourceTypeZ,
+  fields: z.record(schemaFieldZ),
+});
+
+export type Schema = z.infer<typeof schemaZ>;
+
+export const resourceSchemaZ = z
+  .object({
+    id: ID.z,
+    name: z.string(),
+    schema: schemaZ.optional(),
+    data: z.record(z.unknown()).optional(),
+  })
+  .transform((resource) => {
+    return {
+      key: resource.id.toString(),
+      ...resource,
+    };
+  });
+
+export type Resource = z.infer<typeof resourceSchemaZ>;
+
+export const relationshipSchemaZ = z.object({
+  from: ID.z,
+  type: z.string(),
+  to: ID.z,
+});
+
+export type Relationship = z.infer<typeof relationshipSchemaZ>;
+
+export const parseRelationship = (str: string): Relationship => {
+  const [from, type, to] = str.split("->");
+  return {
+    from: new ID(from),
+    type,
+    to: new ID(to),
+  };
+};

package/src/ontology/retriever.ts

@@ -0,0 +1,91 @@
+// Copyright 2023 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import type { UnaryClient } from "@synnaxlabs/freighter";
+import { toArray } from "@synnaxlabs/x";
+import { z } from "zod";
+
+import { ID, type Resource, idZ, resourceSchemaZ } from "@/ontology/payload";
+
+const requestSchema = z.object({
+  ids: idZ.array().optional(),
+  children: z.boolean().optional(),
+  parents: z.boolean().optional(),
+  includeSchema: z.boolean().optional(),
+  includeFieldData: z.boolean().optional(),
+  term: z.string().optional(),
+});
+
+type Request = z.infer<typeof requestSchema>;
+
+const responseSchema = z.object({
+  resources: resourceSchemaZ.array(),
+});
+
+export class Retriever {
+  private static readonly ENDPOINT = "/ontology/retrieve";
+  private readonly client: UnaryClient;
+
+  constructor(unary: UnaryClient) {
+    this.client = unary;
+  }
+
+  async search(term: string): Promise<Resource[]> {
+    const resources = await this.execute({ term });
+    return resources;
+  }
+
+  async retrieve(
+    ids: ID | ID[] | string | string[],
+    includeSchema: boolean = true,
+    includeFieldData: boolean = true,
+  ): Promise<Resource[]> {
+    return await this.execute({
+      ids: toArray(ids).map((id) => new ID(id).payload),
+      includeFieldData,
+      includeSchema,
+    });
+  }
+
+  async retrieveChildren(
+    ids: ID | ID[],
+    includeSchema: boolean = true,
+    includeFieldData: boolean = true,
+  ): Promise<Resource[]> {
+    return await this.execute({
+      ids: toArray(ids).map((id) => new ID(id).payload),
+      children: true,
+      includeSchema,
+      includeFieldData,
+    });
+  }
+
+  async retrieveParents(
+    ids: ID | ID[],
+    includeSchema: boolean = true,
+    includeFieldData: boolean = true,
+  ): Promise<Resource[]> {
+    return await this.execute({
+      ids: toArray(ids).map((id) => new ID(id).payload),
+      parents: true,
+      includeSchema,
+      includeFieldData,
+    });
+  }
+
+  private async execute(request: Request): Promise<Resource[]> {
+    const [res, err] = await this.client.send(
+      Retriever.ENDPOINT,
+      request,
+      responseSchema,
+    );
+    if (err != null) throw err;
+    return res.resources;
+  }
+}

package/src/ontology/writer.ts

@@ -0,0 +1,49 @@
+// Copyright 2023 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { z } from "zod";
+
+import { type ID } from "@/ontology/payload";
+
+const ENDPOINTS = {
+  ADD_CHILDREN: "/ontology/add-children",
+  REMOVE_CHILDREN: "/ontology/remove-children",
+  MOVE_CHILDREN: "/ontology/move-children",
+};
+
+export class Writer {
+  client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async addChildren(id: ID, ...children: ID[]): Promise<void> {
+    const req = { id, children };
+    const [, err] = await this.client.send(ENDPOINTS.ADD_CHILDREN, req, z.object({}));
+    if (err != null) throw err;
+  }
+
+  async removeChildren(id: ID, ...children: ID[]): Promise<void> {
+    const req = { id, children };
+    const [, err] = await this.client.send(
+      ENDPOINTS.REMOVE_CHILDREN,
+      req,
+      z.object({}),
+    );
+    if (err != null) throw err;
+  }
+
+  async moveChildren(from: ID, to: ID, ...children: ID[]): Promise<void> {
+    const req = { from, to, children };
+    const [, err] = await this.client.send(ENDPOINTS.MOVE_CHILDREN, req, z.object({}));
+    if (err != null) throw err;
+  }
+}

package/src/ranger/active.ts

@@ -0,0 +1,56 @@
+// Copyright 2023 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { z } from "zod";
+
+import { QueryError } from "..";
+
+import { type Payload, payloadZ, type Key } from "./payload";
+
+const setActiveResZ = z.object({});
+
+const retrieveActiveResZ = z.object({
+  range: payloadZ,
+});
+
+const clearActiveResZ = z.object({});
+
+const SET_ENDPOINT = "/range/set-active";
+const RETRIEVE_ENDPOINT = "/range/retrieve-active";
+const CLEAR_ENDPOINT = "/range/clear-active";
+
+export class Active {
+  private readonly client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async setActive(range: Key): Promise<void> {
+    const [, err] = await this.client.send(SET_ENDPOINT, { range }, setActiveResZ);
+    if (err != null) throw err;
+  }
+
+  async retrieveActive(): Promise<Payload | null> {
+    const [res, err] = await this.client.send(
+      RETRIEVE_ENDPOINT,
+      {},
+      retrieveActiveResZ,
+    );
+    if (err instanceof QueryError) return null;
+    if (err != null) throw err;
+    return res.range;
+  }
+
+  async clearActive(range: Key): Promise<void> {
+    const [, err] = await this.client.send(CLEAR_ENDPOINT, { range }, clearActiveResZ);
+    if (err != null) throw err;
+  }
+}