@synnaxlabs/client 0.30.0 → 0.31.0

package/src/ontology/payload.ts

@@ -19,12 +19,14 @@ export type RelationshipDelete = change.Delete<Relationship, undefined>;
 
 export const resourceTypeZ = z.union([
   z.literal("label"),
+  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"),
@@ -35,25 +37,22 @@ export const resourceTypeZ = z.union([
   z.literal("task"),
   z.literal("policy"),
 ]);
-
 export type ResourceType = z.infer<typeof resourceTypeZ>;
 
-export const BuiltinOntologyType = "builtin" as ResourceType;
-export const ClusterOntologyType = "cluster" as ResourceType;
-export const NodeOntologyType = "node" as ResourceType;
+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 const stringIDZ = z.string().transform((v) => {
   const [type, key] = v.split(":");
-  return { type: type as ResourceType, key };
+  return { type: resourceTypeZ.parse(type), key: key ?? "" };
 });
 
 export const crudeIDZ = z.union([stringIDZ, idZ]);
-
-export type CrudeID = { type: ResourceType; key: string } | string;
+export type CrudeID = z.input<typeof crudeIDZ>;
 
 export class ID {
   type: ResourceType;
@@ -63,35 +62,40 @@ export class ID {
     if (args instanceof ID) {
       this.type = args.type;
       this.key = args.key;
-    } else if (typeof args === "string") {
+      return;
+    }
+    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;
+      this.key = key ?? "";
+      return;
     }
+    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,
-    };
+  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([crudeIDZ, z.instanceof(ID)]).transform((v) => new ID(v));
+  static readonly z = z.union([z.instanceof(ID), crudeIDZ.transform((v) => new ID(v))]);
 }
 
 export const Root = new ID({ type: "builtin", key: "root" });
 
-export const schemaFieldZ = z.object({
-  type: z.number(),
-});
+export const schemaFieldZ = z.object({ type: z.number() });
 
 export type SchemaField = z.infer<typeof schemaFieldZ>;
 
@@ -99,7 +103,6 @@ export const schemaZ = z.object({
   type: resourceTypeZ,
   fields: z.record(schemaFieldZ),
 });
-
 export type Schema = z.infer<typeof schemaZ>;
 
 export const resourceSchemaZ = z
@@ -109,12 +112,7 @@ export const resourceSchemaZ = z
     schema: schemaZ.optional().nullable(),
     data: z.record(z.unknown()).optional().nullable(),
   })
-  .transform((resource) => {
-    return {
-      key: resource.id.toString(),
-      ...resource,
-    };
-  });
+  .transform((resource) => ({ key: resource.id.toString(), ...resource }));
 
 export type Resource<T extends UnknownRecord = UnknownRecord> = Omit<
   z.output<typeof resourceSchemaZ>,
@@ -123,12 +121,7 @@ export type Resource<T extends UnknownRecord = UnknownRecord> = Omit<
 
 export type RelationshipDirection = "from" | "to";
 
-export const relationshipSchemaZ = z.object({
-  from: ID.z,
-  type: z.string(),
-  to: ID.z,
-});
-
+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 => {

package/src/ranger/payload.ts

@@ -28,9 +28,7 @@ export const payloadZ = z.object({
 });
 export type Payload = z.infer<typeof payloadZ>;
 
-export const newPayloadZ = payloadZ.extend({
-  key: z.string().uuid().optional(),
-});
+export const newPayloadZ = payloadZ.extend({ key: z.string().uuid().optional() });
 export type NewPayload = z.input<typeof newPayloadZ>;
 
 export type ParamAnalysisResult =
@@ -77,11 +75,11 @@ export const analyzeParams = (ranges: Params): ParamAnalysisResult => {
   } as const as ParamAnalysisResult;
 };
 
-export const RangeOntologyType = "range" as ontology.ResourceType;
-export const RangeAliasOntologyType = "range-alias" as ontology.ResourceType;
+export const ONTOLOGY_TYPE: ontology.ResourceType = "range";
+export const ALIAS_ONTOLOGY_TYPE: ontology.ResourceType = "range-alias";
 
 export const rangeOntologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: RangeOntologyType, key: key });
+  new ontology.ID({ type: ONTOLOGY_TYPE, key: key });
 
 export const rangeAliasOntologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: RangeAliasOntologyType, key: key });
+  new ontology.ID({ type: ALIAS_ONTOLOGY_TYPE, key: key });

package/src/setupspecs.ts

@@ -11,8 +11,8 @@ import Synnax, { type SynnaxProps } from "@/client";
 
 export const HOST = "localhost";
 export const PORT = 9090;
-const USERNAME = "synnax"
-const PASSWORD = "seldon"
+const USERNAME = "synnax";
+const PASSWORD = "seldon";
 
 export const newClient = (...props: SynnaxProps[]): Synnax => {
   let _props = {};

package/src/user/client.ts

@@ -7,31 +7,75 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { toArray } from "@synnaxlabs/x";
 
-import { insecureCredentialsZ, tokenResponseZ } from "@/auth/auth";
-import { Payload } from "@/user/payload";
-
-const REGISTER_ENDPOINT = "/user/register";
+import { MultipleFoundError, NotFoundError } from "@/errors";
+import { type Key, type NewUser, type User } from "@/user/payload";
+import { Retriever } from "@/user/retriever";
+import { Writer } from "@/user/writer";
 
 export class Client {
-  private readonly client: UnaryClient;
+  private readonly reader: Retriever;
+  private readonly writer: Writer;
 
   constructor(client: UnaryClient) {
-    this.client = client;
+    this.writer = new Writer(client);
+    this.reader = new Retriever(client);
+  }
+
+  async create(user: NewUser): Promise<User>;
+
+  async create(users: NewUser[]): Promise<User[]>;
+
+  async create(users: NewUser | NewUser[]): Promise<User | User[]> {
+    const isMany = Array.isArray(users);
+    const res = await this.writer.create(users);
+    return isMany ? res : res[0];
   }
 
-  async register(username: string, password: string): Promise<Payload> {
-    const { user } = await sendRequired<
-      typeof insecureCredentialsZ,
-      typeof tokenResponseZ
-    >(
-      this.client,
-      REGISTER_ENDPOINT,
-      { username: username, password: password },
-      insecureCredentialsZ,
-      tokenResponseZ,
-    );
-    return user;
+  async changeUsername(key: Key, newUsername: string): Promise<void> {
+    await this.writer.changeUsername(key, newUsername);
+  }
+
+  async retrieve(key: Key): Promise<User>;
+
+  async retrieve(keys: Key[]): Promise<User[]>;
+
+  async retrieve(keys: Key | Key[]): Promise<User | User[]> {
+    const isMany = Array.isArray(keys);
+    const res = await this.reader.retrieve({ keys: toArray(keys) });
+    if (isMany) return res;
+    if (res.length === 0) throw new NotFoundError(`No user with key ${keys} found`);
+    if (res.length > 1)
+      throw new MultipleFoundError(`Multiple users found with key ${keys}`);
+    return res[0];
+  }
+
+  async retrieveByName(username: string): Promise<User>;
+
+  async retrieveByName(usernames: string[]): Promise<User[]>;
+
+  async retrieveByName(usernames: string | string[]): Promise<User | User[]> {
+    const isMany = Array.isArray(usernames);
+    const res = await this.reader.retrieve({ usernames: toArray(usernames) });
+    if (isMany) return res;
+    if (res.length === 0)
+      throw new NotFoundError(`No user with username ${usernames} found`);
+    if (res.length > 1)
+      throw new MultipleFoundError(`Multiple users found with username ${usernames}`);
+    return res[0];
+  }
+
+  async rename(key: Key, firstName?: string, lastName?: string): Promise<void> {
+    await this.writer.rename(key, firstName, lastName);
+  }
+
+  async delete(key: Key): Promise<void>;
+
+  async delete(keys: Key[]): Promise<void>;
+
+  async delete(keys: Key | Key[]): Promise<void> {
+    await this.writer.delete(keys);
   }
 }

package/src/user/payload.ts

@@ -12,17 +12,24 @@ import { z } from "zod";
 import { ontology } from "@/ontology";
 
 export const keyZ = z.string().uuid();
-
 export type Key = z.infer<typeof keyZ>;
 
-export const payloadZ = z.object({
-  key: z.string(),
-  username: z.string(),
+export const userZ = z.object({
+  key: keyZ,
+  username: z.string().min(1),
+  firstName: z.string(),
+  lastName: z.string(),
+  rootUser: z.boolean(),
 });
+export type User = z.infer<typeof userZ>;
 
-export type Payload = z.infer<typeof payloadZ>;
+export const newUserZ = userZ
+  .partial({ key: true, firstName: true, lastName: true })
+  .omit({ rootUser: true })
+  .extend({ password: z.string().min(1) });
+export type NewUser = z.infer<typeof newUserZ>;
 
-export const UserOntologyType = "user" as ontology.ResourceType;
+export const ONTOLOGY_TYPE: ontology.ResourceType = "user";
 
 export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: UserOntologyType, key });
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });

package/src/user/retriever.ts

@@ -0,0 +1,41 @@
+// Copyright 2024 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 { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { z } from "zod";
+
+import { keyZ, type User, userZ } from "@/user/payload";
+import { nullableArrayZ } from "@/util/zod";
+
+const reqZ = z.object({
+  keys: keyZ.array().optional(),
+  usernames: z.string().array().optional(),
+});
+type Request = z.infer<typeof reqZ>;
+const resZ = z.object({ users: nullableArrayZ(userZ) });
+const ENDPOINT = "/user/retrieve";
+
+export class Retriever {
+  private readonly client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async retrieve(req: Request): Promise<User[]> {
+    const res = await sendRequired<typeof reqZ, typeof resZ>(
+      this.client,
+      ENDPOINT,
+      req,
+      reqZ,
+      resZ,
+    );
+    return res.users;
+  }
+}

package/src/user/user.spec.ts

@@ -0,0 +1,289 @@
+// Copyright 2024 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 { id } from "@synnaxlabs/x";
+import { describe, expect, test } from "vitest";
+
+import { AuthError, NotFoundError } from "@/errors";
+import { newClient } from "@/setupspecs";
+import { type user } from "@/user";
+
+type SortType = { username: string };
+
+const sort = (a: SortType, b: SortType) => a.username.localeCompare(b.username);
+
+const client = newClient();
+
+const userOne: user.NewUser = {
+  username: id.id(),
+  password: "test",
+  firstName: "George",
+  lastName: "Washington",
+};
+
+const userTwo: user.NewUser = { username: id.id(), password: "test" };
+
+const userThree: user.NewUser = {
+  username: id.id(),
+  password: "test",
+  firstName: "John",
+  lastName: "Adams",
+};
+
+const userArray: user.NewUser[] = [
+  { username: id.id(), password: "secondTest", firstName: "Steve" },
+  { username: id.id(), password: "testArray" },
+].sort(sort);
+
+describe("User", () => {
+  describe("Create", () => {
+    describe("One", () => {
+      test("with a name", async () => {
+        const res = await client.user.create(userOne);
+        expect(res.username).toEqual(userOne.username);
+        expect(res.key).not.toEqual("");
+        expect(res.firstName).toEqual(userOne.firstName);
+        expect(res.lastName).toEqual(userOne.lastName);
+        userOne.key = res.key;
+      });
+      test("with no name", async () => {
+        const res = await client.user.create(userTwo);
+        expect(res.username).toEqual(userTwo.username);
+        expect(res.key).not.toEqual("");
+        userTwo.key = res.key;
+        expect(res.firstName).toEqual("");
+        expect(res.lastName).toEqual("");
+      });
+      test("Repeated username", async () =>
+        await expect(
+          client.user.create({ username: userOne.username, password: "test" }),
+        ).rejects.toThrow(AuthError));
+    });
+    describe("Many", () => {
+      test("array empty", async () => {
+        const res = await client.user.create([]);
+        expect(res).toHaveLength(0);
+      });
+      test("array is one", async () => {
+        const res = await client.user.create([userThree]);
+        expect(res).toHaveLength(1);
+        expect(res[0].username).toEqual(userThree.username);
+        expect(res[0].key).not.toEqual("");
+        userThree.key = res[0].key;
+        expect(res[0].firstName).toEqual(userThree.firstName);
+        expect(res[0].lastName).toEqual(userThree.lastName);
+      });
+      test("array not empty", async () => {
+        const res = await client.user.create(userArray);
+        expect(res).toHaveLength(2);
+        userArray.forEach((u, i) => {
+          expect(res[i].username).toEqual(u.username);
+          expect(res[i].key).not.toEqual("");
+          userArray[i].key = res[i].key;
+          expect(res[i].firstName).toEqual(u.firstName ?? "");
+          expect(res[i].lastName).toEqual(u.lastName ?? "");
+        });
+      });
+      test("Repeated username", async () =>
+        await expect(client.user.create([userOne, userTwo])).rejects.toThrow(
+          AuthError,
+        ));
+    });
+  });
+  describe("Retrieve", () => {
+    describe("by name", () => {
+      describe("one", () => {
+        test("found", async () => {
+          const res = await client.user.retrieveByName(userOne.username);
+          expect(res.username).toEqual(userOne.username);
+          expect(res.key).toEqual(userOne.key);
+          expect(res.firstName).toEqual(userOne.firstName);
+          expect(res.lastName).toEqual(userOne.lastName);
+        });
+        test("not found", async () =>
+          await expect(client.user.retrieveByName(id.id())).rejects.toThrow(
+            NotFoundError,
+          ));
+      });
+      describe("many", () => {
+        test("found", async () => {
+          const res = await client.user.retrieveByName(
+            userArray.map((u) => u.username),
+          );
+          expect(res.sort(sort)).toHaveLength(2);
+          res.forEach((u, i) => {
+            expect(u.username).toEqual(userArray[i].username);
+            expect(u.key).toEqual(userArray[i].key);
+            expect(u.firstName).toEqual(userArray[i].firstName ?? "");
+            expect(u.lastName).toEqual(userArray[i].lastName ?? "");
+          });
+        });
+        test("not found", async () => {
+          const res = await client.user.retrieveByName([id.id()]);
+          expect(res).toEqual([]);
+        });
+        test("extra names getting deleted", async () => {
+          const res = await client.user.retrieveByName([
+            ...userArray.map((u) => u.username),
+            id.id(),
+          ]);
+          expect(res.sort(sort)).toHaveLength(2);
+          res.forEach((u, i) => {
+            expect(u.username).toEqual(userArray[i].username);
+            expect(u.key).toEqual(userArray[i].key);
+            expect(u.firstName).toEqual(userArray[i].firstName ?? "");
+            expect(u.lastName).toEqual(userArray[i].lastName ?? "");
+          });
+        });
+        test("calling with no names", async () => {
+          const res = await client.user.retrieveByName([]);
+          const usernames = res.map((u) => u.username);
+          expect(usernames).toContain(userOne.username);
+          expect(usernames).toContain(userTwo.username);
+          expect(usernames).toContain(userThree.username);
+          userArray.forEach((u) => expect(usernames).toContain(u.username));
+        });
+      });
+    });
+    describe("by key", () => {
+      describe("one", () => {
+        test("found", async () => {
+          const res = await client.user.retrieve(userOne.key as string);
+          expect(res.username).toEqual(userOne.username);
+          expect(res.key).toEqual(userOne.key);
+          expect(res.firstName).toEqual(userOne.firstName);
+          expect(res.lastName).toEqual(userOne.lastName);
+        });
+        test("not found", async () => {
+          await expect(
+            client.user.delete(userOne.key as string),
+          ).resolves.toBeUndefined();
+          await expect(client.user.retrieve(userOne.key as string)).rejects.toThrow(
+            NotFoundError,
+          );
+          const u = await client.user.create(userOne);
+          userOne.key = u.key;
+        });
+      });
+      describe("many", () => {
+        test("found", async () => {
+          const res = await client.user.retrieve(userArray.map((u) => u.key as string));
+          expect(res.sort(sort)).toHaveLength(2);
+          res.forEach((u, i) => {
+            expect(u.username).toEqual(userArray[i].username);
+            expect(u.key).toEqual(userArray[i].key);
+            expect(u.firstName).toEqual(userArray[i].firstName ?? "");
+            expect(u.lastName).toEqual(userArray[i].lastName ?? "");
+          });
+        });
+        test("not found", async () => {
+          for (const u of userArray) {
+            await expect(client.user.delete(u.key as string)).resolves.toBeUndefined();
+          }
+          await expect(
+            client.user.retrieve(userArray.map((u) => u.key as string)),
+          ).rejects.toThrow(NotFoundError);
+          // cleanup
+          const users = await client.user.create(userArray);
+          users.forEach((u, i) => (userArray[i].key = u.key));
+        });
+        test("all", async () => {
+          const res = await client.user.retrieve([]);
+          const usernames = res.map((u) => u.username);
+          expect(usernames).toContain(userOne.username);
+          expect(usernames).toContain(userTwo.username);
+          expect(usernames).toContain(userThree.username);
+          userArray.forEach((u) => expect(usernames).toContain(u.username));
+        });
+      });
+    });
+  });
+  describe("Change Username", () => {
+    test("Successful", async () => {
+      const newUsername = id.id();
+      await expect(
+        client.user.changeUsername(userOne.key as string, newUsername),
+      ).resolves.toBeUndefined();
+      const res = await client.user.retrieveByName(newUsername);
+      expect(res.username).toEqual(newUsername);
+      expect(res.key).not.toEqual("");
+      expect(res.firstName).toEqual(userOne.firstName);
+      expect(res.lastName).toEqual(userOne.lastName);
+      userOne.username = newUsername;
+    });
+    test("Unsuccessful", async () =>
+      await expect(
+        client.user.changeUsername(userTwo.key as string, userOne.username),
+      ).rejects.toThrow(AuthError));
+    test("Repeated usernames fail", async () => {
+      const oldUsername = id.id();
+      const user = await client.user.create({
+        username: oldUsername,
+        password: "test",
+      });
+      const newUsername = id.id();
+      await client.user.changeUsername(user.key, newUsername);
+      await expect(
+        client.user.create({ username: newUsername, password: "test" }),
+      ).rejects.toThrow(AuthError);
+    });
+  });
+  describe("Change Name", () => {
+    test("Successful", async () => {
+      await expect(
+        client.user.rename(userOne.key as string, "Thomas", "Jefferson"),
+      ).resolves.toBeUndefined();
+      const res = await client.user.retrieve(userOne.key as string);
+      expect(res.username).toEqual(userOne.username);
+      expect(res.key).toEqual(userOne.key);
+      expect(res.firstName).toEqual("Thomas");
+      expect(res.lastName).toEqual("Jefferson");
+      userOne.firstName = "Thomas";
+      userOne.lastName = "Jefferson";
+    });
+    test("Only one name", async () => {
+      await expect(
+        client.user.rename(userOne.key as string, "James"),
+      ).resolves.toBeUndefined();
+      const res = await client.user.retrieve(userOne.key as string);
+      expect(res.username).toEqual(userOne.username);
+      expect(res.key).toEqual(userOne.key);
+      expect(res.firstName).toEqual("James");
+      expect(res.lastName).toEqual(userOne.lastName);
+      userOne.firstName = "James";
+    });
+  });
+  describe("Delete", () => {
+    test("one that exists", async () => {
+      await expect(client.user.delete(userOne.key as string)).resolves.toBeUndefined();
+      await expect(client.user.retrieve(userOne.key as string)).rejects.toThrow(
+        NotFoundError,
+      );
+    });
+    test("many that exist", async () => {
+      await expect(
+        client.user.delete(userArray.map((u) => u.key as string)),
+      ).resolves.toBeUndefined();
+      await expect(
+        client.user.retrieve(userArray.map((u) => u.key as string)),
+      ).rejects.toThrow(NotFoundError);
+    });
+    test("one that doesn't exist", async () => {
+      await expect(client.user.delete(userOne.key as string)).resolves.toBeUndefined();
+    });
+    test("many where some don't exist", async () => {
+      await expect(
+        client.user.delete([userOne.key as string, userTwo.key as string]),
+      ).resolves.toBeUndefined();
+      await expect(client.user.retrieve(userTwo.key as string)).rejects.toThrow(
+        NotFoundError,
+      );
+    });
+  });
+});