@synnaxlabs/client 0.38.1 → 0.40.0

package/src/hardware/device/payload.ts

@@ -10,44 +10,45 @@
 import { binary, type UnknownRecord } from "@synnaxlabs/x";
 import { z } from "zod";
 
-import { rackKeyZ } from "@/hardware/rack/payload";
-import { ontology } from "@/ontology";
+import { keyZ as rackKeyZ } from "@/hardware/rack/payload";
+import { decodeJSONString } from "@/util/decodeJSONString";
 
-export const deviceKeyZ = z.string();
+export const keyZ = z.string();
+export type Key = z.infer<typeof keyZ>;
 
 export const deviceZ = z.object({
-  key: deviceKeyZ,
+  key: keyZ,
   rack: rackKeyZ,
   name: z.string(),
   make: z.string(),
   model: z.string(),
   location: z.string(),
   configured: z.boolean().optional(),
-  properties: z.record(z.unknown()).or(
-    z.string().transform((c) => {
-      if (c === "") return {};
-      return binary.JSON_CODEC.decodeString(c);
-    }),
-  ) as z.ZodType<UnknownRecord>,
+  properties: z.record(z.unknown()).or(z.string().transform(decodeJSONString)),
 });
 
-export type Device<P extends UnknownRecord = UnknownRecord> = Omit<
-  z.output<typeof deviceZ>,
-  "properties"
-> & { properties: P };
-
-export type DeviceKey = z.infer<typeof deviceKeyZ>;
-
-export const newDeviceZ = deviceZ.extend({
+export interface Device<
+  Properties extends UnknownRecord = UnknownRecord,
+  Make extends string = string,
+  Model extends string = string,
+> extends Omit<z.output<typeof deviceZ>, "properties"> {
+  properties: Properties;
+  make: Make;
+  model: Model;
+}
+
+export const newZ = deviceZ.extend({
   properties: z.unknown().transform((c) => binary.JSON_CODEC.encodeString(c)),
 });
-
-export type NewDevice<P extends UnknownRecord = UnknownRecord> = Omit<
-  z.input<typeof newDeviceZ>,
-  "properties"
-> & { properties: P };
-
-export const ONTOLOGY_TYPE: ontology.ResourceType = "device";
-
-export const ontologyID = (key: DeviceKey): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key: key.toString() });
+export interface New<
+  Properties extends UnknownRecord = UnknownRecord,
+  Make extends string = string,
+  Model extends string = string,
+> extends Omit<z.input<typeof newZ>, "properties"> {
+  properties: Properties;
+  make: Make;
+  model: Model;
+}
+
+export const ONTOLOGY_TYPE = "device";
+export type OntologyType = typeof ONTOLOGY_TYPE;

package/src/hardware/rack/client.ts

@@ -13,84 +13,69 @@ import { type AsyncTermSearcher } from "@synnaxlabs/x/search";
 import { toArray } from "@synnaxlabs/x/toArray";
 import { z } from "zod";
 
-import { type framer } from "@/framer";
 import {
-  type NewRack,
-  newRackZ,
-  type RackKey,
-  rackKeyZ,
-  type RackPayload,
+  type Key,
+  keyZ,
+  type New,
+  newZ,
+  ONTOLOGY_TYPE,
+  type Payload,
   rackZ,
 } from "@/hardware/rack/payload";
 import { type task } from "@/hardware/task";
+import { ontology } from "@/ontology";
 import { analyzeParams, checkForMultipleOrNoResults } from "@/util/retrieve";
 import { nullableArrayZ } from "@/util/zod";
 
 const RETRIEVE_ENDPOINT = "/hardware/rack/retrieve";
-const CREATE_RACK_ENDPOINT = "/hardware/rack/create";
-const DELETE_RACK_ENDPOINT = "/hardware/rack/delete";
+const CREATE_ENDPOINT = "/hardware/rack/create";
+const DELETE_ENDPOINT = "/hardware/rack/delete";
 
-const retrieveRackReqZ = z.object({
-  keys: rackKeyZ.array().optional(),
+const retrieveReqZ = z.object({
+  keys: keyZ.array().optional(),
   names: z.string().array().optional(),
   search: z.string().optional(),
   offset: z.number().optional(),
   limit: z.number().optional(),
 });
 
-const retrieveRackResZ = z.object({
-  racks: nullableArrayZ(rackZ),
-});
+const retrieveResZ = z.object({ racks: nullableArrayZ(rackZ) });
 
-const createReqZ = z.object({
-  racks: newRackZ.array(),
-});
+const createReqZ = z.object({ racks: newZ.array() });
 
-const createResZ = z.object({
-  racks: rackZ.array(),
-});
+const createResZ = z.object({ racks: rackZ.array() });
 
-const deleteReqZ = z.object({
-  keys: rackKeyZ.array(),
-});
+const deleteReqZ = z.object({ keys: keyZ.array() });
 
 const deleteResZ = z.object({});
 
-export class Client implements AsyncTermSearcher<string, RackKey, Rack> {
-  readonly type: string = "rack";
+export class Client implements AsyncTermSearcher<string, Key, Payload> {
+  readonly type = ONTOLOGY_TYPE;
   private readonly client: UnaryClient;
-  private readonly frameClient: framer.Client;
   private readonly tasks: task.Client;
 
-  constructor(
-    client: UnaryClient,
-    frameClient: framer.Client,
-    taskClient: task.Client,
-  ) {
+  constructor(client: UnaryClient, taskClient: task.Client) {
     this.client = client;
-    this.frameClient = frameClient;
     this.tasks = taskClient;
   }
 
-  async delete(keys: RackKey | RackKey[]): Promise<void> {
+  async delete(keys: Key | Key[]): Promise<void> {
     await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
       this.client,
-      DELETE_RACK_ENDPOINT,
+      DELETE_ENDPOINT,
       { keys: toArray(keys) },
       deleteReqZ,
       deleteResZ,
     );
   }
 
-  async create(rack: NewRack): Promise<Rack>;
-
-  async create(racks: NewRack[]): Promise<Rack[]>;
-
-  async create(rack: NewRack | NewRack[]): Promise<Rack | Rack[]> {
+  async create(rack: New): Promise<Rack>;
+  async create(racks: New[]): Promise<Rack[]>;
+  async create(rack: New | New[]): Promise<Rack | Rack[]> {
     const isSingle = !Array.isArray(rack);
     const res = await sendRequired<typeof createReqZ, typeof createResZ>(
       this.client,
-      CREATE_RACK_ENDPOINT,
+      CREATE_ENDPOINT,
       { racks: toArray(rack) },
       createReqZ,
       createResZ,
@@ -101,64 +86,60 @@ export class Client implements AsyncTermSearcher<string, RackKey, Rack> {
   }
 
   async search(term: string): Promise<Rack[]> {
-    const res = await sendRequired<typeof retrieveRackReqZ, typeof retrieveRackResZ>(
+    const res = await sendRequired<typeof retrieveReqZ, typeof retrieveResZ>(
       this.client,
       RETRIEVE_ENDPOINT,
       { search: term },
-      retrieveRackReqZ,
-      retrieveRackResZ,
+      retrieveReqZ,
+      retrieveResZ,
     );
     return this.sugar(res.racks);
   }
 
   async page(offset: number, limit: number): Promise<Rack[]> {
-    const res = await sendRequired<typeof retrieveRackReqZ, typeof retrieveRackResZ>(
+    const res = await sendRequired<typeof retrieveReqZ, typeof retrieveResZ>(
       this.client,
       RETRIEVE_ENDPOINT,
       { offset, limit },
-      retrieveRackReqZ,
-      retrieveRackResZ,
+      retrieveReqZ,
+      retrieveResZ,
     );
     return this.sugar(res.racks);
   }
 
-  async retrieve(key: string | RackKey): Promise<Rack>;
-
-  async retrieve(keys: number[] | RackKey[]): Promise<Rack[]>;
-
-  async retrieve(
-    racks: string | RackKey | string[] | RackKey[],
-  ): Promise<Rack | Rack[]> {
+  async retrieve(key: string | Key): Promise<Rack>;
+  async retrieve(keys: Key[]): Promise<Rack[]>;
+  async retrieve(racks: string | Key | Key[]): Promise<Rack | Rack[]> {
     const { variant, normalized, single } = analyzeParams(racks, {
       string: "names",
       number: "keys",
     });
-    const res = await sendRequired<typeof retrieveRackReqZ, typeof retrieveRackResZ>(
+    const res = await sendRequired<typeof retrieveReqZ, typeof retrieveResZ>(
       this.client,
       RETRIEVE_ENDPOINT,
       { [variant]: normalized },
-      retrieveRackReqZ,
-      retrieveRackResZ,
+      retrieveReqZ,
+      retrieveResZ,
     );
     const sugared = this.sugar(res.racks);
     checkForMultipleOrNoResults("Rack", racks, sugared, single);
     return single ? sugared[0] : sugared;
   }
 
-  private sugar(payloads: RackPayload[]): Rack[] {
+  private sugar(payloads: Payload[]): Rack[] {
     return payloads.map(({ key, name }) => new Rack(key, name, this.tasks));
   }
 }
 
 export class Rack {
-  key: number;
+  key: Key;
   name: string;
   private readonly tasks: task.Client;
 
-  constructor(key: number, name: string, client: task.Client) {
+  constructor(key: Key, name: string, taskClient: task.Client) {
     this.key = key;
     this.name = name;
-    this.tasks = client;
+    this.tasks = taskClient;
   }
 
   async listTasks(): Promise<task.Task[]> {
@@ -169,20 +150,26 @@ export class Rack {
     return await this.tasks.retrieveByName(name, this.key);
   }
 
+  async retrieveTaskByType(type: string): Promise<task.Task[]> {
+    return await this.tasks.retrieveByType(type, this.key);
+  }
+
   async createTask<
-    C extends UnknownRecord,
-    D extends {} = UnknownRecord,
-    T extends string = string,
-  >(task: task.NewTask<C, T>): Promise<task.Task<C, D, T>> {
+    Config extends UnknownRecord,
+    Details extends {} = UnknownRecord,
+    Type extends string = string,
+  >(task: task.New<Config, Type>): Promise<task.Task<Config, Details, Type>> {
     task.key = (
       (BigInt(this.key) << 32n) +
       (BigInt(task.key ?? 0) & 0xffffffffn)
     ).toString();
-    return await this.tasks.create<C, D, T>(task);
+    return await this.tasks.create<Config, Details, Type>(task);
   }
 
   async deleteTask(task: bigint): Promise<void> {
     await this.tasks.delete([task]);
   }
 }
-export { rackKeyZ };
+
+export const ontologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: ONTOLOGY_TYPE, key: key.toString() });

package/src/hardware/rack/payload.ts

@@ -7,26 +7,17 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+import { zod } from "@synnaxlabs/x";
 import { z } from "zod";
 
-import { ontology } from "@/ontology";
+export const keyZ = zod.uint32;
+export type Key = z.infer<typeof keyZ>;
 
-export const rackKeyZ = z.number();
+export const rackZ = z.object({ key: keyZ, name: z.string() });
+export interface Payload extends z.infer<typeof rackZ> {}
 
-export type RackKey = z.infer<typeof rackKeyZ>;
+export const newZ = rackZ.partial({ key: true });
+export interface New extends z.input<typeof newZ> {}
 
-export const rackZ = z.object({
-  key: rackKeyZ,
-  name: z.string(),
-});
-
-export type RackPayload = z.infer<typeof rackZ>;
-
-export const newRackZ = rackZ.partial({ key: true });
-
-export type NewRack = z.input<typeof newRackZ>;
-
-export const ONTOLOGY_TYPE: ontology.ResourceType = "rack";
-
-export const ontologyID = (key: RackKey): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key: key.toString() });
+export const ONTOLOGY_TYPE = "rack";
+export type OntologyType = typeof ONTOLOGY_TYPE;

package/src/hardware/rack/rack.spec.ts

@@ -26,6 +26,18 @@ describe("Rack", () => {
       await expect(client.hardware.racks.create({})).rejects.toThrow(ZodError);
     });
   });
+  describe("update", () => {
+    it("should update a rack if the key is provided", async () => {
+      const r = await client.hardware.racks.create({ name: "test" });
+      const updated = await client.hardware.racks.create({
+        key: r.key,
+        name: "updated",
+      });
+      expect(updated.name).toBe("updated");
+      const retrieved = await client.hardware.racks.retrieve(r.key);
+      expect(retrieved.name).toBe("updated");
+    });
+  });
   describe("retrieve", () => {
     it("should retrieve a rack by its key", async () => {
       const r = await client.hardware.racks.create({ name: "test" });