@synnaxlabs/client 0.43.1 → 0.44.2

package/src/ontology/ontology.spec.ts

@@ -10,13 +10,118 @@
 import { describe, expect, it, test } from "vitest";
 
 import { ontology } from "@/ontology";
-import { newClient } from "@/setupspecs";
+import { createTestClient } from "@/testutil/client";
 
-const client = newClient();
+const client = createTestClient();
 
 const randomName = (): string => `group-${Math.random()}`;
 
 describe("Ontology", () => {
+  describe("parseIDs", () => {
+    it("should parse a single ID object", () => {
+      const id: ontology.ID = { type: "group", key: "test-key" };
+      const result = ontology.parseIDs(id);
+      expect(result).toEqual([id]);
+    });
+
+    it("should parse an array of ID objects", () => {
+      const ids: ontology.ID[] = [
+        { type: "group", key: "test-key-1" },
+        { type: "channel", key: "test-key-2" },
+      ];
+      const result = ontology.parseIDs(ids);
+      expect(result).toEqual(ids);
+    });
+
+    it("should parse a single string ID", () => {
+      const stringId = "group:test-key";
+      const result = ontology.parseIDs(stringId);
+      expect(result).toEqual([{ type: "group", key: "test-key" }]);
+    });
+
+    it("should parse an array of string IDs", () => {
+      const stringIds = ["group:test-key-1", "channel:test-key-2"];
+      const result = ontology.parseIDs(stringIds);
+      expect(result).toEqual([
+        { type: "group", key: "test-key-1" },
+        { type: "channel", key: "test-key-2" },
+      ]);
+    });
+
+    it("should extract ID from a single Resource object", () => {
+      const resource: ontology.Resource = {
+        id: { type: "group", key: "test-key" },
+        name: "Test Resource",
+        key: "group:test-key",
+      };
+      const result = ontology.parseIDs(resource);
+      expect(result).toEqual([{ type: "group", key: "test-key" }]);
+    });
+
+    it("should extract IDs from an array of Resource objects", () => {
+      const resources: ontology.Resource[] = [
+        {
+          id: { type: "group", key: "test-key-1" },
+          name: "Test Resource 1",
+          key: "group:test-key-1",
+        },
+        {
+          id: { type: "channel", key: "test-key-2" },
+          name: "Test Resource 2",
+          key: "channel:test-key-2",
+        },
+      ];
+      const result = ontology.parseIDs(resources);
+      expect(result).toEqual([
+        { type: "group", key: "test-key-1" },
+        { type: "channel", key: "test-key-2" },
+      ]);
+    });
+
+    it("should return empty array for empty input", () => {
+      const result = ontology.parseIDs([]);
+      expect(result).toEqual([]);
+    });
+
+    it("should handle string IDs with colons in the key", () => {
+      const stringId = "group:test:key:with:colons";
+      const result = ontology.parseIDs(stringId);
+      expect(result).toEqual([{ type: "group", key: "test" }]);
+    });
+
+    it("should handle mixed Resource objects with different data types", () => {
+      const resources: ontology.Resource[] = [
+        {
+          id: { type: "group", key: "test-key-1" },
+          name: "Test Resource 1",
+          key: "group:test-key-1",
+          data: { customField: "value" },
+        },
+        {
+          id: { type: "channel", key: "test-key-2" },
+          name: "Test Resource 2",
+          key: "channel:test-key-2",
+          data: null,
+        },
+      ];
+      const result = ontology.parseIDs(resources);
+      expect(result).toEqual([
+        { type: "group", key: "test-key-1" },
+        { type: "channel", key: "test-key-2" },
+      ]);
+    });
+
+    it("should throw an error for invalid string ID format", () => {
+      const invalidStringId = "invalid-format";
+      expect(() => ontology.parseIDs(invalidStringId)).toThrow();
+    });
+
+    it("should throw an error for invalid resource type in string ID", () => {
+      const invalidStringId = "invalid-type:test-key";
+      expect(() => ontology.parseIDs(invalidStringId)).toThrow();
+    });
+  });
+
   describe("retrieve", () => {
     test("retrieve", async () => {
       const name = randomName();
@@ -43,20 +148,6 @@ describe("Ontology", () => {
       expect(parents[0].name).toEqual(name);
     });
   });
-  describe("page", () => {
-    it("should return a page of resources", async () => {
-      for (let i = 0; i < 10; i++)
-        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);
-      expect(page2.length).toEqual(5);
-      const page1Keys = page.map((r) => r.key);
-      const page2Keys = page2.map((r) => r.key);
-      const intersection = page1Keys.filter((key) => page2Keys.includes(key));
-      expect(intersection.length).toEqual(0);
-    });
-  });
   describe("write", () => {
     test("add children", async () => {
       const name = randomName();
@@ -93,36 +184,259 @@ describe("Ontology", () => {
       expect(newRootLength).toEqual(oldRootLength - 1);
     });
   });
+
   describe("signals", 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");
+      const rel = ontology.relationshipZ.parse("table:keyA->parent->schematic:keyB");
+      expect(rel.type).toEqual(ontology.PARENT_OF_RELATIONSHIP_TYPE);
+      expect(rel.from.type).toEqual("table");
       expect(rel.from.key).toEqual("keyA");
-      expect(rel.to.type).toEqual("typeB");
+      expect(rel.to.type).toEqual("schematic");
       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_ID, 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_ID, randomName());
-      const c = await p;
-      expect(c.length).toBeGreaterThan(0);
-      await change.close();
+  });
+
+  describe("matchRelationship", () => {
+    const sampleRelationship: ontology.Relationship = {
+      from: { type: "group", key: "test-group" },
+      type: "parent",
+      to: { type: "channel", key: "test-channel" },
+    };
+
+    describe("type matching", () => {
+      it("should return true when types match", () => {
+        const match: ontology.MatchRelationshipArgs = { type: "parent" };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(true);
+      });
+
+      it("should return false when types don't match", () => {
+        const match: ontology.MatchRelationshipArgs = { type: "child" };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(false);
+      });
+    });
+
+    describe("from ID matching", () => {
+      it("should return true when from type matches", () => {
+        const match: ontology.MatchRelationshipArgs = {
+          type: "parent",
+          from: { type: "group" },
+        };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(true);
+      });
+
+      it("should return true when from key matches", () => {
+        const match: ontology.MatchRelationshipArgs = {
+          type: "parent",
+          from: { key: "test-group" },
+        };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(true);
+      });
+
+      it("should return true when both from type and key match", () => {
+        const match: ontology.MatchRelationshipArgs = {
+          type: "parent",
+          from: { type: "group", key: "test-group" },
+        };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(true);
+      });
+
+      it("should return false when from type doesn't match", () => {
+        const match: ontology.MatchRelationshipArgs = {
+          type: "parent",
+          from: { type: "channel" },
+        };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(false);
+      });
+
+      it("should return false when from key doesn't match", () => {
+        const match: ontology.MatchRelationshipArgs = {
+          type: "parent",
+          from: { key: "wrong-key" },
+        };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(false);
+      });
+
+      it("should return false when from type matches but key doesn't", () => {
+        const match: ontology.MatchRelationshipArgs = {
+          type: "parent",
+          from: { type: "group", key: "wrong-key" },
+        };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(false);
+      });
+    });
+
+    describe("to ID matching", () => {
+      it("should return true when to type matches", () => {
+        const match: ontology.MatchRelationshipArgs = {
+          type: "parent",
+          to: { type: "channel" },
+        };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(true);
+      });
+
+      it("should return true when to key matches", () => {
+        const match: ontology.MatchRelationshipArgs = {
+          type: "parent",
+          to: { key: "test-channel" },
+        };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(true);
+      });
+
+      it("should return true when both to type and key match", () => {
+        const match: ontology.MatchRelationshipArgs = {
+          type: "parent",
+          to: { type: "channel", key: "test-channel" },
+        };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(true);
+      });
+
+      it("should return false when to type doesn't match", () => {
+        const match: ontology.MatchRelationshipArgs = {
+          type: "parent",
+          to: { type: "group" },
+        };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(false);
+      });
+
+      it("should return false when to key doesn't match", () => {
+        const match = { type: "parent", to: { key: "wrong-key" } };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(false);
+      });
+
+      it("should return false when to type matches but key doesn't", () => {
+        const match: ontology.MatchRelationshipArgs = {
+          type: "parent",
+          to: { type: "channel", key: "wrong-key" },
+        };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(false);
+      });
+    });
+
+    describe("combined matching", () => {
+      it("should return true when all specified criteria match", () => {
+        const match: ontology.MatchRelationshipArgs = {
+          type: "parent",
+          from: { type: "group", key: "test-group" },
+          to: { type: "channel", key: "test-channel" },
+        };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(true);
+      });
+
+      it("should return false when type matches but from doesn't", () => {
+        const match: ontology.MatchRelationshipArgs = {
+          type: "parent",
+          from: { type: "channel" },
+          to: { type: "channel", key: "test-channel" },
+        };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(false);
+      });
+
+      it("should return false when type matches but to doesn't", () => {
+        const match: ontology.MatchRelationshipArgs = {
+          type: "parent",
+          from: { type: "group", key: "test-group" },
+          to: { type: "group" },
+        };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(false);
+      });
+
+      it("should return false when from and to match but type doesn't", () => {
+        const match: ontology.MatchRelationshipArgs = {
+          type: "child",
+          from: { type: "group", key: "test-group" },
+          to: { type: "channel", key: "test-channel" },
+        };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(false);
+      });
+    });
+
+    describe("partial matching", () => {
+      it("should return true when only type is specified and matches", () => {
+        const match: ontology.MatchRelationshipArgs = { type: "parent" };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(true);
+      });
+
+      it("should return true when only from type is specified and matches", () => {
+        const match: ontology.MatchRelationshipArgs = {
+          type: "parent",
+          from: { type: "group" },
+        };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(true);
+      });
+
+      it("should return true when only to type is specified and matches", () => {
+        const match: ontology.MatchRelationshipArgs = {
+          type: "parent",
+          to: { type: "channel" },
+        };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(true);
+      });
+
+      it("should return true when only from key is specified and matches", () => {
+        const match: ontology.MatchRelationshipArgs = {
+          type: "parent",
+          from: { key: "test-group" },
+        };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(true);
+      });
+
+      it("should return true when only to key is specified and matches", () => {
+        const match: ontology.MatchRelationshipArgs = {
+          type: "parent",
+          to: { key: "test-channel" },
+        };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(true);
+      });
+    });
+
+    describe("edge cases", () => {
+      it("should handle empty from and to objects", () => {
+        const match: ontology.MatchRelationshipArgs = {
+          type: "parent",
+          from: {},
+          to: {},
+        };
+        const result = ontology.matchRelationship(sampleRelationship, match);
+        expect(result).toBe(true);
+      });
+
+      it("should handle relationships with empty keys", () => {
+        const relationship: ontology.Relationship = {
+          from: { type: "group", key: "" },
+          type: "parent",
+          to: { type: "channel", key: "" },
+        };
+        const match: ontology.MatchRelationshipArgs = {
+          type: "parent",
+          from: { key: "" },
+          to: { key: "" },
+        };
+        const result = ontology.matchRelationship(relationship, match);
+        expect(result).toBe(true);
+      });
     });
   });
 });

package/src/ontology/payload.ts

@@ -7,30 +7,8 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { type change, type UnknownRecord, unknownRecordZ } from "@synnaxlabs/x";
-import { z } from "zod/v4";
-
-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";
+import { array, type change, record } from "@synnaxlabs/x";
+import { z } from "zod";
 
 export type ResourceChange = change.Change<ID, Resource>;
 export interface ResourceSet extends change.Set<ID, Resource> {}
@@ -44,113 +22,100 @@ 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,
+  "label",
+  "log",
+  "allow_all",
+  "builtin",
+  "cluster",
+  "channel",
+  "node",
+  "group",
+  "range",
+  "framer",
+  "range-alias",
+  "user",
+  "workspace",
+  "schematic",
+  "lineplot",
+  "rack",
+  "device",
+  "task",
+  "policy",
+  "table",
 ]);
 export type ResourceType = z.infer<typeof resourceTypeZ>;
 
-export const idZ = z.object({ type: resourceTypeZ, key: z.string() });
-export interface IDPayload extends z.infer<typeof idZ> {}
-
-export const stringIDZ = z.string().transform((v) => {
+const stringIDZ = z.string().transform((v) => {
   const [type, key] = v.split(":");
   return { type: resourceTypeZ.parse(type), key: key ?? "" };
 });
 
-export const crudeIDZ = z.union([stringIDZ, idZ]);
-export type CrudeID = z.input<typeof crudeIDZ>;
-
-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;
-      return;
-    }
-    if (typeof args === "string") {
-      const [type, key] = args.split(":");
-      this.type = type as ResourceType;
-      this.key = key ?? "";
-      return;
-    }
-    this.type = args.type;
-    this.key = args.key;
-  }
-
-  toString(): string {
-    return `${this.type}:${this.key}`;
-  }
-
-  isType(): boolean {
-    return this.key === "";
-  }
-
-  matchesType(type: ResourceType): boolean {
-    return this.type === type && this.isType();
-  }
-
-  get payload(): IDPayload {
-    return { type: this.type, key: this.key };
-  }
-
-  static readonly z = z.union([z.instanceof(ID), crudeIDZ.transform((v) => new ID(v))]);
-}
+export const idZ = z.object({ type: resourceTypeZ, key: z.string() }).or(stringIDZ);
 
-export const ROOT_ID = new ID({ type: BUILTIN_TYPE, key: "root" });
+export type ID = z.infer<typeof idZ>;
 
-export const schemaFieldZ = z.object({ type: z.number() });
-export interface SchemaField extends z.infer<typeof schemaFieldZ> {}
+export const ROOT_ID: ID = { type: BUILTIN_TYPE, key: "root" };
 
-export const schemaZ = z.object({
-  type: resourceTypeZ,
-  fields: z.record(z.string(), schemaFieldZ),
-});
-export interface Schema extends z.infer<typeof schemaZ> {}
+export const idToString = (id: ID) => `${id.type}:${id.key}`;
+
+export const idsEqual = (a: ID, b: ID) => a.type === b.type && a.key === b.key;
+
+export const parseIDs = (
+  ids: ID | ID[] | string | string[] | Resource | Resource[],
+): ID[] => {
+  const arr = array.toArray(ids);
+  if (arr.length === 0) return [];
+  if (typeof arr[0] === "object" && "id" in arr[0])
+    return (arr as Resource[]).map(({ id }) => id);
+  return arr.map((id) => idZ.parse(id));
+};
 
 export const resourceZ = z
   .object({
-    id: ID.z,
+    id: idZ,
     name: z.string(),
-    schema: schemaZ.optional().nullable(),
-    data: unknownRecordZ.optional().nullable(),
+    data: record.unknownZ.optional().nullable(),
   })
-  .transform((resource) => ({ key: resource.id.toString(), ...resource }));
-export interface Resource<T extends UnknownRecord = UnknownRecord>
+  .transform((resource) => ({ key: idToString(resource.id), ...resource }));
+export interface Resource<T extends record.Unknown = record.Unknown>
   extends Omit<z.infer<typeof resourceZ>, "data"> {
   data?: T | null;
 }
 
-export const TO_RELATIONSHIP_DIRECTION = "to";
-export const FROM_RELATIONSHIP_DIRECTION = "from";
-export type RelationshipDirection =
-  | typeof TO_RELATIONSHIP_DIRECTION
-  | typeof FROM_RELATIONSHIP_DIRECTION;
+export type RelationshipDirection = "to" | "from";
 
-export const relationshipSchemaZ = z.object({ from: ID.z, type: z.string(), to: ID.z });
-export interface Relationship extends z.infer<typeof relationshipSchemaZ> {}
+export const oppositeRelationshipDirection = (
+  direction: RelationshipDirection,
+): RelationshipDirection => (direction === "to" ? "from" : "to");
+
+export const relationshipZ = z.object({ from: idZ, type: z.string(), to: idZ }).or(
+  z.string().transform((v) => {
+    const [from, type, to] = v.split("->");
+    return { from: idZ.parse(from), type, to: idZ.parse(to) };
+  }),
+);
+export type Relationship = z.infer<typeof relationshipZ>;
+
+export const relationshipToString = (relationship: Relationship) =>
+  `${idToString(relationship.from)}->${relationship.type}->${idToString(relationship.to)}`;
+
+export const PARENT_OF_RELATIONSHIP_TYPE = "parent";
+
+export interface MatchRelationshipArgs {
+  from?: Partial<ID>;
+  type: string;
+  to?: Partial<ID>;
+}
 
-export const parseRelationship = (str: string): Relationship => {
-  const [from, type, to] = str.split("->");
-  return { from: new ID(from), type, to: new ID(to) };
+export const matchRelationship = (
+  relationship: Relationship,
+  match: MatchRelationshipArgs,
+) => {
+  if (match.type != null && match.type !== relationship.type) return false;
+  if (match.from?.type != null && match.from.type !== relationship.from.type)
+    return false;
+  if (match.to?.type != null && match.to.type !== relationship.to.type) return false;
+  if (match.from?.key != null && match.from.key !== relationship.from.key) return false;
+  if (match.to?.key != null && match.to.key !== relationship.to.key) return false;
+  return true;
 };