@synnaxlabs/client 0.38.1 → 0.39.0

package/src/ontology/group/writer.ts

@@ -10,42 +10,38 @@
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { z } from "zod";
 
-import { groupZ, type Payload } from "@/ontology/group/payload";
-import { type ID, idZ } from "@/ontology/payload";
+import {
+  groupZ,
+  type Key,
+  keyZ,
+  type Name,
+  nameZ,
+  type Payload,
+} from "@/ontology/group/payload";
+import { type ID as OntologyID, idZ as ontologyIDZ } from "@/ontology/payload";
 
-const resZ = z.object({
-  group: groupZ,
-});
+const resZ = z.object({ group: groupZ });
 
-const createReqZ = z.object({
-  parent: idZ,
-  key: z.string().uuid().optional(),
-  name: z.string(),
-});
+const createReqZ = z.object({ parent: ontologyIDZ, key: keyZ.optional(), name: nameZ });
 
-const renameReqZ = z.object({
-  key: z.string(),
-  name: z.string(),
-});
+const renameReqZ = z.object({ key: keyZ, name: nameZ });
 
-const deleteReqZ = z.object({
-  keys: z.array(z.string()),
-});
+const deleteReqZ = z.object({ keys: z.array(keyZ) });
 
 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";
+  private static readonly CREATE_ENDPOINT = "/ontology/create-group";
+  private static readonly RENAME_ENDPOINT = "/ontology/rename-group";
+  private static readonly DELETE_ENDPOINT = "/ontology/delete-group";
   client: UnaryClient;
 
   constructor(client: UnaryClient) {
     this.client = client;
   }
 
-  async create(parent: ID, name: string, key?: string): Promise<Payload> {
+  async create(parent: OntologyID, name: Name, key?: Key): Promise<Payload> {
     const res = await sendRequired(
       this.client,
-      Writer.ENDPOINT,
+      Writer.CREATE_ENDPOINT,
       { parent, name, key },
       createReqZ,
       resZ,
@@ -53,20 +49,20 @@ export class Writer {
     return res.group;
   }
 
-  async rename(key: string, name: string): Promise<void> {
+  async rename(key: Key, name: Name): Promise<void> {
     await sendRequired(
       this.client,
-      Writer.ENDPOINT_RENAME,
+      Writer.RENAME_ENDPOINT,
       { key, name },
       renameReqZ,
       z.object({}),
     );
   }
 
-  async delete(keys: string[]): Promise<void> {
+  async delete(keys: Key[]): Promise<void> {
     await sendRequired(
       this.client,
-      Writer.ENDPOINT_DELETE,
+      Writer.DELETE_ENDPOINT,
       { keys },
       deleteReqZ,
       z.object({}),

package/src/ontology/ontology.spec.ts

@@ -20,13 +20,13 @@ describe("Ontology", () => {
   describe("retrieve", () => {
     test("retrieve", async () => {
       const name = randomName();
-      const g = await client.ontology.groups.create(ontology.Root, name);
+      const g = await client.ontology.groups.create(ontology.ROOT_ID, 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 g = await client.ontology.groups.create(ontology.ROOT_ID, name);
       const name2 = randomName();
       await client.ontology.groups.create(g.ontologyID, name2);
       const children = await client.ontology.retrieveChildren(g.ontologyID);
@@ -35,7 +35,7 @@ describe("Ontology", () => {
     });
     test("retrieve parents", async () => {
       const name = randomName();
-      const g = await client.ontology.groups.create(ontology.Root, name);
+      const g = await client.ontology.groups.create(ontology.ROOT_ID, name);
       const name2 = randomName();
       const g2 = await client.ontology.groups.create(g.ontologyID, name2);
       const parents = await client.ontology.retrieveParents(g2.ontologyID);
@@ -46,7 +46,7 @@ describe("Ontology", () => {
   describe("page", () => {
     it("should return a page of resources", async () => {
       for (let i = 0; i < 10; i++)
-        await client.ontology.groups.create(ontology.Root, randomName());
+        await client.ontology.groups.create(ontology.ROOT_ID, randomName());
       const page = await client.ontology.page(0, 5);
       expect(page.length).toEqual(5);
       const page2 = await client.ontology.page(5, 5);
@@ -60,9 +60,9 @@ describe("Ontology", () => {
   describe("write", () => {
     test("add children", async () => {
       const name = randomName();
-      const g = await client.ontology.groups.create(ontology.Root, name);
+      const g = await client.ontology.groups.create(ontology.ROOT_ID, name);
       const name2 = randomName();
-      const g2 = await client.ontology.groups.create(ontology.Root, name2);
+      const g2 = await client.ontology.groups.create(ontology.ROOT_ID, name2);
       await client.ontology.addChildren(g.ontologyID, g2.ontologyID);
       const children = await client.ontology.retrieveChildren(g.ontologyID);
       expect(children.length).toEqual(1);
@@ -70,9 +70,9 @@ describe("Ontology", () => {
     });
     test("remove children", async () => {
       const name = randomName();
-      const g = await client.ontology.groups.create(ontology.Root, name);
+      const g = await client.ontology.groups.create(ontology.ROOT_ID, name);
       const name2 = randomName();
-      const g2 = await client.ontology.groups.create(ontology.Root, name2);
+      const g2 = await client.ontology.groups.create(ontology.ROOT_ID, 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);
@@ -80,15 +80,15 @@ describe("Ontology", () => {
     });
     test("move children", async () => {
       const name = randomName();
-      const g = await client.ontology.groups.create(ontology.Root, name);
+      const g = await client.ontology.groups.create(ontology.ROOT_ID, name);
       const name2 = randomName();
-      const g2 = await client.ontology.groups.create(ontology.Root, name2);
-      const oldRootLength = (await client.ontology.retrieveChildren(ontology.Root))
+      const g2 = await client.ontology.groups.create(ontology.ROOT_ID, name2);
+      const oldRootLength = (await client.ontology.retrieveChildren(ontology.ROOT_ID))
         .length;
-      await client.ontology.moveChildren(ontology.Root, g.ontologyID, g2.ontologyID);
+      await client.ontology.moveChildren(ontology.ROOT_ID, 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))
+      const newRootLength = (await client.ontology.retrieveChildren(ontology.ROOT_ID))
         .length;
       expect(newRootLength).toEqual(oldRootLength - 1);
     });
@@ -107,7 +107,7 @@ describe("Ontology", () => {
       const p = new Promise<ontology.ResourceChange[]>((resolve) =>
         change.resources.onChange((changes) => resolve(changes)),
       );
-      await client.ontology.groups.create(ontology.Root, randomName());
+      await client.ontology.groups.create(ontology.ROOT_ID, randomName());
       const c = await p;
       expect(c.length).toBeGreaterThan(0);
       await change.close();
@@ -119,7 +119,7 @@ describe("Ontology", () => {
           resolve(changes);
         });
       });
-      await client.ontology.groups.create(ontology.Root, randomName());
+      await client.ontology.groups.create(ontology.ROOT_ID, randomName());
       const c = await p;
       expect(c.length).toBeGreaterThan(0);
       await change.close();

package/src/ontology/payload.ts

@@ -10,43 +10,65 @@
 import { type change, type UnknownRecord } from "@synnaxlabs/x";
 import { z } from "zod";
 
+import {
+  ALLOW_ALL_ONTOLOGY_TYPE as ALLOW_ALL_TYPE,
+  ONTOLOGY_TYPE as POLICY_TYPE,
+} from "@/access/policy/ontology";
+import { ONTOLOGY_TYPE as CHANNEL_TYPE } from "@/channel/payload";
+import { ONTOLOGY_TYPE as FRAMER_TYPE } from "@/framer/frame";
+import { ONTOLOGY_TYPE as DEVICE_TYPE } from "@/hardware/device/payload";
+import { ONTOLOGY_TYPE as RACK_TYPE } from "@/hardware/rack/payload";
+import { ONTOLOGY_TYPE as TASK_TYPE } from "@/hardware/task/payload";
+import { ONTOLOGY_TYPE as LABEL_TYPE } from "@/label/payload";
+import { ONTOLOGY_TYPE as GROUP_TYPE } from "@/ontology/group/payload";
+import {
+  ALIAS_ONTOLOGY_TYPE as RANGE_ALIAS_TYPE,
+  ONTOLOGY_TYPE as RANGE_TYPE,
+} from "@/ranger/payload";
+import { ONTOLOGY_TYPE as USER_TYPE } from "@/user/payload";
+import { ONTOLOGY_TYPE as LINE_PLOT_TYPE } from "@/workspace/lineplot/payload";
+import { ONTOLOGY_TYPE as LOG_TYPE } from "@/workspace/log/payload";
+import { ONTOLOGY_TYPE as WORKSPACE_TYPE } from "@/workspace/payload";
+import { ONTOLOGY_TYPE as SCHEMATIC_TYPE } from "@/workspace/schematic/payload";
+import { ONTOLOGY_TYPE as TABLE_TYPE } from "@/workspace/table/payload";
+
 export type ResourceChange = change.Change<ID, Resource>;
-export type ResourceSet = change.Set<ID, Resource>;
-export type ResourceDelete = change.Delete<ID, Resource>;
+export interface ResourceSet extends change.Set<ID, Resource> {}
+export interface ResourceDelete extends change.Delete<ID, Resource> {}
 export type RelationshipChange = change.Change<Relationship, undefined>;
-export type RelationshipSet = change.Set<Relationship, undefined>;
-export type RelationshipDelete = change.Delete<Relationship, undefined>;
-
-export const resourceTypeZ = z.union([
-  z.literal("label"),
-  z.literal("log"),
-  z.literal("allow_all"),
-  z.literal("builtin"),
-  z.literal("cluster"),
-  z.literal("channel"),
-  z.literal("node"),
-  z.literal("group"),
-  z.literal("range"),
-  z.literal("framer"),
-  z.literal("range-alias"),
-  z.literal("user"),
-  z.literal("workspace"),
-  z.literal("schematic"),
-  z.literal("lineplot"),
-  z.literal("rack"),
-  z.literal("device"),
-  z.literal("task"),
-  z.literal("policy"),
-  z.literal("table"),
+export interface RelationshipSet extends change.Set<Relationship, undefined> {}
+export interface RelationshipDelete extends change.Delete<Relationship, undefined> {}
+
+export const BUILTIN_TYPE = "builtin";
+export const CLUSTER_TYPE = "cluster";
+export const NODE_TYPE = "node";
+
+export const resourceTypeZ = z.enum([
+  LABEL_TYPE,
+  LOG_TYPE,
+  ALLOW_ALL_TYPE,
+  BUILTIN_TYPE,
+  CLUSTER_TYPE,
+  CHANNEL_TYPE,
+  NODE_TYPE,
+  GROUP_TYPE,
+  RANGE_TYPE,
+  FRAMER_TYPE,
+  RANGE_ALIAS_TYPE,
+  USER_TYPE,
+  WORKSPACE_TYPE,
+  SCHEMATIC_TYPE,
+  LINE_PLOT_TYPE,
+  RACK_TYPE,
+  DEVICE_TYPE,
+  TASK_TYPE,
+  POLICY_TYPE,
+  TABLE_TYPE,
 ]);
 export type ResourceType = z.infer<typeof resourceTypeZ>;
 
-export const BUILTIN_TYPE: ResourceType = "builtin";
-export const CLUSTER_TYPE: ResourceType = "cluster";
-export const NODE_TYPE: ResourceType = "node";
-
 export const idZ = z.object({ type: resourceTypeZ, key: z.string() });
-export type IDPayload = z.infer<typeof idZ>;
+export interface IDPayload extends z.infer<typeof idZ> {}
 
 export const stringIDZ = z.string().transform((v) => {
   const [type, key] = v.split(":");
@@ -95,19 +117,18 @@ export class ID {
   static readonly z = z.union([z.instanceof(ID), crudeIDZ.transform((v) => new ID(v))]);
 }
 
-export const Root = new ID({ type: BUILTIN_TYPE, key: "root" });
+export const ROOT_ID = new ID({ type: BUILTIN_TYPE, key: "root" });
 
 export const schemaFieldZ = z.object({ type: z.number() });
-
-export type SchemaField = z.infer<typeof schemaFieldZ>;
+export interface SchemaField extends z.infer<typeof schemaFieldZ> {}
 
 export const schemaZ = z.object({
   type: resourceTypeZ,
   fields: z.record(schemaFieldZ),
 });
-export type Schema = z.infer<typeof schemaZ>;
+export interface Schema extends z.infer<typeof schemaZ> {}
 
-export const resourceSchemaZ = z
+export const resourceZ = z
   .object({
     id: ID.z,
     name: z.string(),
@@ -115,16 +136,19 @@ export const resourceSchemaZ = z
     data: z.record(z.unknown()).optional().nullable(),
   })
   .transform((resource) => ({ key: resource.id.toString(), ...resource }));
+export interface Resource<T extends UnknownRecord = UnknownRecord>
+  extends Omit<z.output<typeof resourceZ>, "data"> {
+  data?: T | null;
+}
 
-export type Resource<T extends UnknownRecord = UnknownRecord> = Omit<
-  z.output<typeof resourceSchemaZ>,
-  "data"
-> & { data?: T | null };
-
-export type RelationshipDirection = "from" | "to";
+export const TO_RELATIONSHIP_DIRECTION = "to";
+export const FROM_RELATIONSHIP_DIRECTION = "from";
+export type RelationshipDirection =
+  | typeof TO_RELATIONSHIP_DIRECTION
+  | typeof FROM_RELATIONSHIP_DIRECTION;
 
 export const relationshipSchemaZ = z.object({ from: ID.z, type: z.string(), to: ID.z });
-export type Relationship = z.infer<typeof relationshipSchemaZ>;
+export interface Relationship extends z.infer<typeof relationshipSchemaZ> {}
 
 export const parseRelationship = (str: string): Relationship => {
   const [from, type, to] = str.split("->");

package/src/ontology/writer.ts

@@ -12,22 +12,15 @@ import { z } from "zod";
 
 import { type CrudeID, ID, idZ } from "@/ontology/payload";
 
-const ENDPOINTS = {
-  ADD_CHILDREN: "/ontology/add-children",
-  REMOVE_CHILDREN: "/ontology/remove-children",
-  MOVE_CHILDREN: "/ontology/move-children",
-};
+const ADD_CHILDREN_ENDPOINT = "/ontology/add-children";
+const REMOVE_CHILDREN_ENDPOINT = "/ontology/remove-children";
+const MOVE_CHILDREN_ENDPOINT = "/ontology/move-children";
 
-const addRemoveChildrenReqZ = z.object({
-  id: idZ,
-  children: idZ.array(),
-});
+const addRemoveChildrenReqZ = z.object({ id: idZ, children: idZ.array() });
 
-const moveChildrenReqZ = z.object({
-  from: idZ,
-  to: idZ,
-  children: idZ.array(),
-});
+const moveChildrenReqZ = z.object({ from: idZ, to: idZ, children: idZ.array() });
+
+const emptyResZ = z.object({});
 
 export class Writer {
   client: UnaryClient;
@@ -37,22 +30,22 @@ export class Writer {
   }
 
   async addChildren(id: CrudeID, ...children: CrudeID[]): Promise<void> {
-    await sendRequired<typeof addRemoveChildrenReqZ, z.ZodTypeAny>(
+    await sendRequired<typeof addRemoveChildrenReqZ, typeof emptyResZ>(
       this.client,
-      ENDPOINTS.ADD_CHILDREN,
+      ADD_CHILDREN_ENDPOINT,
       { id: new ID(id).payload, children: children.map((c) => new ID(c).payload) },
       addRemoveChildrenReqZ,
-      z.object({}),
+      emptyResZ,
     );
   }
 
   async removeChildren(id: CrudeID, ...children: CrudeID[]): Promise<void> {
-    await sendRequired<typeof addRemoveChildrenReqZ, z.ZodTypeAny>(
+    await sendRequired<typeof addRemoveChildrenReqZ, typeof emptyResZ>(
       this.client,
-      ENDPOINTS.REMOVE_CHILDREN,
+      REMOVE_CHILDREN_ENDPOINT,
       { id: new ID(id).payload, children: children.map((c) => new ID(c).payload) },
       addRemoveChildrenReqZ,
-      z.object({}),
+      emptyResZ,
     );
   }
 
@@ -66,12 +59,12 @@ export class Writer {
       to: new ID(to).payload,
       children: children.map((c) => new ID(c).payload),
     };
-    await sendRequired(
+    await sendRequired<typeof moveChildrenReqZ, typeof emptyResZ>(
       this.client,
-      ENDPOINTS.MOVE_CHILDREN,
+      MOVE_CHILDREN_ENDPOINT,
       req,
       moveChildrenReqZ,
-      z.object({}),
+      emptyResZ,
     );
   }
 }

package/src/ranger/alias.ts

@@ -11,73 +11,60 @@ import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { type change } from "@synnaxlabs/x/change";
 import { z } from "zod";
 
-import { type channel } from "@/channel";
-import { type Key as ChannelKey, keyZ as channelKeyZ } from "@/channel/payload";
-import { type Client as FrameClient } from "@/framer/client";
+import { channel } from "@/channel";
+import { type framer } from "@/framer";
 import { type Key, keyZ } from "@/ranger/payload";
 import { signals } from "@/signals";
 
-export const ALIAS_SET_NAME = "sy_range_alias_set";
-export const ALIAS_DELETE_NAME = "sy_range_alias_delete";
+export const SET_ALIAS_CHANNEL_NAME = "sy_range_alias_set";
+export const DELETE_ALIAS_CHANNEL_NAME = "sy_range_alias_delete";
 
-const resolveReqZ = z.object({
-  range: keyZ,
-  aliases: z.string().array(),
-});
+const resolveReqZ = z.object({ range: keyZ, aliases: z.string().array() });
 
-const resolveResZ = z.object({
-  aliases: z.record(z.string(), channelKeyZ),
-});
+const resolveResZ = z.object({ aliases: z.record(z.string(), channel.keyZ) });
 
 const setReqZ = z.object({
   range: keyZ,
-  aliases: z.record(channelKeyZ.or(z.string()), z.string()),
+  aliases: z.record(channel.keyZ.or(z.string()), z.string()),
 });
 
 const setResZ = z.unknown();
 
-const deleteReqZ = z.object({
-  range: keyZ,
-  channels: channelKeyZ.array(),
-});
+const deleteReqZ = z.object({ range: keyZ, channels: channel.keyZ.array() });
 
 const deleteResZ = z.unknown();
 
-const listReqZ = z.object({
-  range: keyZ,
-});
+const listReqZ = z.object({ range: keyZ });
 
-const listResZ = z.object({
-  aliases: z.record(z.string(), z.string()),
-});
+const listResZ = z.object({ aliases: z.record(z.string(), z.string()) });
 
 export class Aliaser {
   private static readonly SET_ENDPOINT = "/range/alias/set";
   private static readonly RESOLVE_ENDPOINT = "/range/alias/resolve";
   private static readonly LIST_ENDPOINT = "/range/alias/list";
   private static readonly DELETE_ENDPOINT = "/range/alias/delete";
-  private readonly frameClient: FrameClient;
-  private readonly cache = new Map<string, ChannelKey>();
+  private readonly frameClient: framer.Client;
+  private readonly cache = new Map<string, channel.Key>();
   private readonly client: UnaryClient;
   private readonly rangeKey: Key;
 
-  constructor(rangeKey: Key, frameClient: FrameClient, client: UnaryClient) {
+  constructor(rangeKey: Key, frameClient: framer.Client, client: UnaryClient) {
     this.rangeKey = rangeKey;
     this.cache = new Map();
     this.client = client;
     this.frameClient = frameClient;
   }
 
-  resolve(aliases: string): Promise<ChannelKey>;
+  resolve(aliases: string): Promise<channel.Key>;
 
-  resolve(aliases: string[]): Promise<Record<string, ChannelKey>>;
+  resolve(aliases: string[]): Promise<Record<string, channel.Key>>;
 
   async resolve(
     aliases: string | string[],
-  ): Promise<ChannelKey | Record<string, ChannelKey>> {
+  ): Promise<channel.Key | Record<string, channel.Key>> {
     const toFetch: string[] = [];
     const isSingle = typeof aliases === "string";
-    const cached: Record<string, ChannelKey> = {};
+    const cached: Record<string, channel.Key> = {};
     if (isSingle) {
       const c = this.cache.get(aliases);
       if (c != null) return c;
@@ -100,7 +87,7 @@ export class Aliaser {
     return isSingle ? res.aliases[toFetch[0]] : { ...cached, ...res.aliases };
   }
 
-  async set(aliases: Record<ChannelKey, string>): Promise<void> {
+  async set(aliases: Record<channel.Key, string>): Promise<void> {
     await sendRequired<typeof setReqZ, typeof setResZ>(
       this.client,
       Aliaser.SET_ENDPOINT,
@@ -110,7 +97,7 @@ export class Aliaser {
     );
   }
 
-  async list(): Promise<Record<ChannelKey, string>> {
+  async list(): Promise<Record<channel.Key, string>> {
     return (
       await sendRequired<typeof listReqZ, typeof listResZ>(
         this.client,
@@ -122,7 +109,7 @@ export class Aliaser {
     ).aliases;
   }
 
-  async delete(aliases: ChannelKey[]): Promise<void> {
+  async delete(aliases: channel.Key[]): Promise<void> {
     await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
       this.client,
       Aliaser.DELETE_ENDPOINT,
@@ -135,8 +122,8 @@ export class Aliaser {
   async openChangeTracker(): Promise<signals.Observable<string, Alias>> {
     return await signals.openObservable<string, Alias>(
       this.frameClient,
-      ALIAS_SET_NAME,
-      ALIAS_DELETE_NAME,
+      SET_ALIAS_CHANNEL_NAME,
+      DELETE_ALIAS_CHANNEL_NAME,
       decodeAliasChanges(this.rangeKey),
     );
   }
@@ -150,13 +137,9 @@ export interface Alias {
 
 export type AliasChange = change.Change<string, Alias>;
 
-const aliasZ = z.object({
-  range: keyZ,
-  channel: channelKeyZ,
-  alias: z.string(),
-});
+const aliasZ = z.object({ range: keyZ, channel: channel.keyZ, alias: z.string() });
 
-const aliasSeparator = "---";
+const separator = "---";
 
 const decodeAliasChanges =
   (rangeKey: Key): signals.Decoder<string, Alias> =>
@@ -164,7 +147,7 @@ const decodeAliasChanges =
     if (variant === "delete")
       return data
         .toStrings()
-        .filter((k) => k.split(aliasSeparator)[0] === rangeKey)
+        .filter((k) => k.split(separator)[0] === rangeKey)
         .map((alias) => ({
           variant,
           key: alias,