@synnaxlabs/client 0.27.0 → 0.28.0

package/src/hardware/task/payload.ts

@@ -55,6 +55,7 @@ export const taskZ = z.object({
     }),
   ) as z.ZodType<UnknownRecord>,
   state: stateZ.optional().nullable(),
+  snapshot: z.boolean().optional(),
 });
 
 export const newTaskZ = taskZ.omit({ key: true }).extend({

package/src/hardware/task/task.spec.ts

@@ -44,46 +44,61 @@ describe("Hardware", () => {
         expect(retrieved.config).toStrictEqual({ a: "dog" });
         expect(retrieved.type).toBe("ni");
       });
-    });
-    describe("retrieveByName", () => {
-      it("should retrieve a task by its name", async () => {
-        const name = `test-${Date.now()}-${Math.random()}`;
-        const r = await client.hardware.racks.create({ name });
-        const m = await r.createTask({
-          name,
-          config: { a: "dog" },
-          type: "ni",
+      describe("retrieveByName", () => {
+        it("should retrieve a task by its name", async () => {
+          const name = `test-${Date.now()}-${Math.random()}`;
+          const r = await client.hardware.racks.create({ name });
+          const m = await r.createTask({
+            name,
+            config: { a: "dog" },
+            type: "ni",
+          });
+          const retrieved = await client.hardware.tasks.retrieveByName(name);
+          expect(retrieved.key).toBe(m.key);
+        });
+      });
+      describe("retrieve with state", () => {
+        it("should also send the tasks state", async () => {
+          const r = await client.hardware.racks.create({ name: "test" });
+          const t = await r.createTask({
+            name: "test",
+            config: { a: "dog" },
+            type: "ni",
+          });
+          const w = await client.openWriter(["sy_task_state"]);
+          interface StateDetails {
+            dog: string;
+          }
+          const state: task.State<StateDetails> = {
+            key: id.id(),
+            task: t.key,
+            variant: "success",
+          };
+          expect(await w.write("sy_task_state", [state])).toBeTruthy();
+          await w.close();
+          const retrieved = await client.hardware.tasks.retrieve(t.key, {
+            includeState: true,
+          });
+          expect(retrieved.state).not.toBeNull();
+          expect(retrieved.state?.variant).toBe(state.variant);
         });
-        const retrieved = await client.hardware.tasks.retrieveByName(name);
-        expect(retrieved.key).toBe(m.key);
       });
     });
-    describe("retrieve with state", () => {
-      it("should also send the tasks state", async () => {
+
+    describe("copy", () => {
+      it("should correctly copy the task", async () => {
         const r = await client.hardware.racks.create({ name: "test" });
-        const t = await r.createTask({
+        const m = await r.createTask({
           name: "test",
           config: { a: "dog" },
           type: "ni",
         });
-        const w = await client.openWriter(["sy_task_state"]);
-        interface StateDetails {
-          dog: string;
-        }
-        const state: task.State<StateDetails> = {
-          key: id.id(),
-          task: t.key,
-          variant: "success",
-        };
-        expect(await w.write("sy_task_state", [state])).toBeTruthy();
-        await w.close();
-        const retrieved = await client.hardware.tasks.retrieve(t.key, {
-          includeState: true,
-        });
-        expect(retrieved.state).not.toBeNull();
-        expect(retrieved.state?.variant).toBe(state.variant);
+        const copy = await client.hardware.tasks.copy(m.key, "New Name", false);
+        expect(copy.name).toBe("New Name");
+        expect(copy.config).toStrictEqual({ a: "dog" });
       });
     });
+
     describe("list", () => {
       it("should list all tasks", async () => {
         const t = await client.hardware.racks.create({ name: "test" });

package/src/label/client.ts

@@ -110,11 +110,11 @@ export class Client implements AsyncTermSearcher<string, Key, Label> {
       name: l.name,
       data: l,
     }));
-    const base = await this.ontology.openDependentTracker(
-      new ontology.ID(id),
-      initial,
-      "labeled_by",
-    );
+    const base = await this.ontology.openDependentTracker({
+      target: new ontology.ID(id),
+      dependents: initial,
+      relationshipType: "labeled_by",
+    });
     base.onChange((resources: ontology.Resource[]) =>
       wrapper.notify(
         resources.map((r) => ({

package/src/ontology/client.ts

@@ -27,6 +27,7 @@ import {
   type Resource,
   ResourceChange,
   resourceSchemaZ,
+  resourceTypeZ,
 } from "@/ontology/payload";
 import { Writer } from "@/ontology/writer";
 
@@ -41,13 +42,14 @@ const retrieveReqZ = z.object({
   term: z.string().optional(),
   limit: z.number().optional(),
   offset: z.number().optional(),
+  types: resourceTypeZ.array().optional(),
 });
 
 type RetrieveRequest = z.infer<typeof retrieveReqZ>;
 
 export type RetrieveOptions = Pick<
   RetrieveRequest,
-  "includeSchema" | "excludeFieldData"
+  "includeSchema" | "excludeFieldData" | "types"
 >;
 
 const retrieveResZ = z.object({
@@ -219,19 +221,9 @@ export class Client implements AsyncTermSearcher<string, string, Resource> {
   }
 
   async openDependentTracker(
-    parent: ID,
-    initial: Resource[],
-    type: string = "parent",
-    direction: RelationshipDirection = "from",
+    props: DependentTrackerProps,
   ): Promise<observe.ObservableAsyncCloseable<Resource[]>> {
-    return await DependentTracker.open(
-      parent,
-      this,
-      this.framer,
-      initial,
-      type,
-      direction,
-    );
+    return await DependentTracker.open(props, this.framer, this);
   }
 
   newSearcherWithOptions(
@@ -372,6 +364,17 @@ export class ChangeTracker {
   }
 }
 
+const oppositeDirection = (dir: RelationshipDirection): RelationshipDirection =>
+  dir === "from" ? "to" : "from";
+
+interface DependentTrackerProps {
+  target: ID;
+  dependents: Resource[];
+  relationshipType?: string;
+  relationshipDirection?: RelationshipDirection;
+  resourceType?: string;
+}
+
 /**
  * A class that tracks a resource (called the 'target' resource) and related resources
  * (called 'dependents') of a particular type (called the 'type') in a Synnax cluster
@@ -383,39 +386,43 @@ export class DependentTracker
 {
   private readonly internal: ChangeTracker;
   private readonly target: ID;
-  private readonly direction: RelationshipDirection;
+  private readonly relDir: RelationshipDirection;
+  private readonly resourceType?: string;
   private dependents: Resource[];
   private readonly client: Client;
-  private readonly type: string;
+  private readonly relType: string;
 
   private constructor(
-    target: ID,
+    {
+      target,
+      dependents,
+      relationshipType = "parent",
+      relationshipDirection = "from",
+      resourceType,
+    }: DependentTrackerProps,
     internal: ChangeTracker,
-    dependents: Resource[],
     client: Client,
-    type: string = "parent",
-    direction: RelationshipDirection = "from",
   ) {
     super();
+    this.resourceType = resourceType;
     this.internal = internal;
     this.target = target;
     this.dependents = dependents;
+    if (this.resourceType != null)
+      this.dependents = this.dependents.filter((r) => r.id.type === this.resourceType);
     this.client = client;
-    this.type = type;
-    this.direction = direction;
+    this.relType = relationshipType;
+    this.relDir = relationshipDirection;
     this.internal.resources.onChange(this.handleResourceChange);
     this.internal.relationships.onChange(this.handleRelationshipChange);
   }
   static async open(
-    from: ID,
-    client: Client,
+    props: DependentTrackerProps,
     framer: framer.Client,
-    initial: Resource[],
-    type: string = "parent",
-    direction: RelationshipDirection = "from",
+    client: Client,
   ): Promise<DependentTracker> {
     const internal = await ChangeTracker.open(framer, client);
-    return new DependentTracker(from, internal, initial, client, type, direction);
+    return new DependentTracker(props, internal, client);
   }
 
   private handleResourceChange = (changes: ResourceChange[]): void => {
@@ -431,20 +438,25 @@ export class DependentTracker
     const deletes = changes.filter(
       (c) =>
         c.variant === "delete" &&
-        c.key[this.direction].toString() === this.target.toString(),
+        c.key[this.relDir].toString() === this.target.toString() &&
+        (this.resourceType == null ||
+          c.key[oppositeDirection(this.relDir)].type === this.resourceType),
     );
     this.dependents = this.dependents.filter(
       (child) =>
         !deletes.some(
           (del) =>
-            del.key.to.toString() === child.id.toString() && del.key.type === this.type,
+            del.key.to.toString() === child.id.toString() &&
+            del.key.type === this.relType,
         ),
     );
     const sets = changes.filter(
       (c) =>
         c.variant === "set" &&
-        c.key.type === this.type &&
-        c.key[this.direction].toString() === this.target.toString(),
+        c.key.type === this.relType &&
+        c.key[this.relDir].toString() === this.target.toString() &&
+        (this.resourceType == null ||
+          c.key[oppositeDirection(this.relDir)].type === this.resourceType),
     );
     if (sets.length === 0) return this.notify(this.dependents);
     this.client.retrieve(sets.map((s) => s.key.to)).then((resources) => {

package/src/ontology/group/writer.ts

@@ -7,10 +7,10 @@
 // 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 { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { z } from "zod";
 
-import { groupZ,type Payload } from "@/ontology/group/payload";
+import { groupZ, type Payload } from "@/ontology/group/payload";
 import { type ID, idZ } from "@/ontology/payload";
 
 const resZ = z.object({
@@ -43,35 +43,33 @@ export class Writer {
   }
 
   async create(parent: ID, name: string, key?: string): Promise<Payload> {
-    const [res, err] = await this.client.send(
+    const res = await sendRequired(
+      this.client,
       Writer.ENDPOINT,
       { parent, name, key },
       createReqZ,
       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(
+    await sendRequired(
+      this.client,
       Writer.ENDPOINT_RENAME,
-      req,
+      { key, name },
       renameReqZ,
       z.object({}),
     );
-    if (err != null) throw err;
   }
 
   async delete(keys: string[]): Promise<void> {
-    const req = { keys };
-    const [, err] = await this.client.send(
+    await sendRequired(
+      this.client,
       Writer.ENDPOINT_DELETE,
-      req,
+      { keys },
       deleteReqZ,
       z.object({}),
     );
-    if (err != null) throw err;
   }
 }

package/src/ontology/ontology.spec.ts

@@ -104,11 +104,9 @@ describe("Ontology", () => {
     });
     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);
-        });
-      });
+      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);

package/src/ontology/payload.ts

@@ -17,7 +17,7 @@ export type RelationshipChange = change.Change<Relationship, undefined>;
 export type RelationshipSet = change.Set<Relationship, undefined>;
 export type RelationshipDelete = change.Delete<Relationship, undefined>;
 
-const resourceTypeZ = z.union([
+export const resourceTypeZ = z.union([
   z.literal("label"),
   z.literal("builtin"),
   z.literal("cluster"),

package/src/ranger/client.ts

@@ -128,6 +128,7 @@ export class Range {
     const res = (
       await this.ontologyClient.retrieveChildren(this.ontologyID, {
         excludeFieldData: true,
+        types: ["range"],
       })
     ).map((r) => r.id.key);
     return await this.rangeClient.retrieve(res);
@@ -159,12 +160,13 @@ export class Range {
       const id = new ontology.ID({ key: r.key, type: "range" });
       return { id, key: id.toString(), name: r.name, data: r.payload };
     });
-    const base = await this.ontologyClient.openDependentTracker(
-      this.ontologyID,
-      initial,
-    );
-    base.onChange((resources: Resource[]) =>
-      wrapper.notify(this.rangeClient.resourcesToRanges(resources)),
+    const base = await this.ontologyClient.openDependentTracker({
+      target: this.ontologyID,
+      dependents: initial,
+      resourceType: "range",
+    });
+    base.onChange((r: Resource[]) =>
+      wrapper.notify(this.rangeClient.resourcesToRanges(r)),
     );
     wrapper.setCloser(async () => await base.close());
     return wrapper;
@@ -176,12 +178,11 @@ export class Range {
     if (p == null) return null;
     const id = new ontology.ID({ key: p.key, type: "range" });
     const resourceP = { id, key: id.toString(), name: p.name, data: p.payload };
-    const base = await this.ontologyClient.openDependentTracker(
-      this.ontologyID,
-      [resourceP],
-      "parent",
-      "to",
-    );
+    const base = await this.ontologyClient.openDependentTracker({
+      target: this.ontologyID,
+      dependents: [resourceP],
+      relationshipDirection: "to",
+    });
     base.onChange((resources: Resource[]) => {
       const ranges = this.rangeClient.resourcesToRanges(resources);
       if (ranges.length === 0) return;
@@ -244,7 +245,7 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
     options?: CreateOptions,
   ): Promise<Range | Range[]> {
     const single = !Array.isArray(ranges);
-    const res = this.sugar(await this.writer.create(toArray(ranges), options));
+    const res = this.sugarMany(await this.writer.create(toArray(ranges), options));
     return single ? res[0] : res;
   }
 
@@ -257,11 +258,11 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
   }
 
   async search(term: string): Promise<Range[]> {
-    return this.sugar(await this.execRetrieve({ term }));
+    return this.sugarMany(await this.execRetrieve({ term }));
   }
 
   async page(offset: number, limit: number): Promise<Range[]> {
-    return this.sugar(await this.execRetrieve({ offset, limit }));
+    return this.sugarMany(await this.execRetrieve({ offset, limit }));
   }
 
   async retrieve(range: CrudeTimeRange): Promise<Range[]>;
@@ -296,7 +297,7 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
       retrieveReqZ,
       retrieveResZ,
     );
-    return this.sugar(ranges);
+    return this.sugarMany(ranges);
   }
 
   async retrieveParent(range: Key): Promise<Range | null> {
@@ -310,22 +311,24 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
     return await this.retrieve(first.id.key);
   }
 
-  sugar(payloads: Payload[]): Range[] {
-    return payloads.map((payload) => {
-      return new Range(
-        payload.name,
-        payload.timeRange,
-        payload.key,
-        payload.color,
-        this.frameClient,
-        new KV(payload.key, this.unaryClient, this.frameClient),
-        new Aliaser(payload.key, this.frameClient, this.unaryClient),
-        this.channels,
-        this.labelClient,
-        this.ontologyClient,
-        this,
-      );
-    });
+  sugarOne(payload: Payload): Range {
+    return new Range(
+      payload.name,
+      payload.timeRange,
+      payload.key,
+      payload.color,
+      this.frameClient,
+      new KV(payload.key, this.unaryClient, this.frameClient),
+      new Aliaser(payload.key, this.frameClient, this.unaryClient),
+      this.channels,
+      this.labelClient,
+      this.ontologyClient,
+      this,
+    );
+  }
+
+  sugarMany(payloads: Payload[]): Range[] {
+    return payloads.map((payload) => this.sugarOne(payload));
   }
 
   async openTracker(): Promise<signals.Observable<string, Range>> {
@@ -336,19 +339,22 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
       (variant, data) => {
         if (variant === "delete")
           return data.toStrings().map((k) => ({ variant, key: k, value: undefined }));
-        const sugared = this.sugar(data.parseJSON(payloadZ));
+        const sugared = this.sugarMany(data.parseJSON(payloadZ));
         return sugared.map((r) => ({ variant, key: r.key, value: r }));
       },
     );
   }
 
   resourcesToRanges(resources: Resource[]): Range[] {
-    return this.sugar(
-      resources.map((r) => ({
-        key: r.id.key,
-        name: r.data?.name as string,
-        timeRange: new TimeRange(r.data?.timeRange as CrudeTimeRange),
-      })),
-    );
+    return resources.map((r) => this.resourceToRange(r));
+  }
+
+  resourceToRange(resource: Resource): Range {
+    return this.sugarOne({
+      key: resource.id.key,
+      name: resource.data?.name as string,
+      timeRange: new TimeRange(resource.data?.timeRange as CrudeTimeRange),
+      color: resource.data?.color as string,
+    });
   }
 }

package/src/vite-env.d.ts

@@ -7,5 +7,5 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
- 
 /// <reference types="vite/client" />
+declare const __VERSION__: string;

package/vite.config.ts

@@ -10,7 +10,12 @@
 import { lib } from "@synnaxlabs/vite-plugin";
 import { defineConfig } from "vite";
 
+import packageJSON from "./package.json";
+
 export default defineConfig({
+  define: {
+    __VERSION__: JSON.stringify(packageJSON.version),
+  },
   plugins: [lib({ name: "client" })],
   build: {
     rollupOptions: {