@synnaxlabs/client 0.29.0 → 0.31.0

package/src/ontology/client.ts

@@ -13,19 +13,18 @@ import { type AsyncTermSearcher } from "@synnaxlabs/x/search";
 import { z } from "zod";
 
 import { QueryError } from "@/errors";
-import { framer } from "@/framer";
-import { Frame } from "@/framer/frame";
+import { type framer } from "@/framer";
 import { group } from "@/ontology/group";
 import {
-  CrudeID,
+  type CrudeID,
   ID,
-  IDPayload,
+  type IDPayload,
   idZ,
   parseRelationship,
-  RelationshipChange,
-  RelationshipDirection,
+  type RelationshipChange,
+  type RelationshipDirection,
   type Resource,
-  ResourceChange,
+  type ResourceChange,
   resourceSchemaZ,
   resourceTypeZ,
 } from "@/ontology/payload";
@@ -92,12 +91,12 @@ export class Client implements AsyncTermSearcher<string, string, Resource> {
 
   /**
    * Retrieves the resource in the ontology with the given ID.
-   * @param id The ID of the resource to retrieve.
-   * @param options Additional options for the retrieval.
-   * @param options.includeSchema Whether to include the schema of the resource in the
+   * @param id - The ID of the resource to retrieve.
+   * @param options - Additional options for the retrieval.
+   * @param options.includeSchema - Whether to include the schema of the resource in the
    * results.
-   * @param options.excludeFieldData Whether to exclude the field data of the resource in
-   * the results.
+   * @param options.excludeFieldData - Whether to exclude the field data of the resource
+   * in the results.
    * @returns The resource with the given ID.
    * @throws {QueryError} If no resource is found with the given ID.
    */
@@ -105,12 +104,13 @@ export class Client implements AsyncTermSearcher<string, string, Resource> {
 
   /**
    * Retrieves the resources in the ontology with the given IDs.
-   * @param ids The IDs of the resources to retrieve.
-   * @param options Additional options for the retrieval.
-   * @param options.includeSchema Whether to include the schema of the resources in the
-   * results.
-   * @param options.excludeFieldData Whether to exclude the field data of the resources in
+   *
+   * @param ids - The IDs of the resources to retrieve.
+   * @param options - Additional options for the retrieval.
+   * @param options.includeSchema - Whether to include the schema of the resources in
    * the results.
+   * @param options.excludeFieldData - Whether to exclude the field data of the
+   * resources in the results.
    * @returns The resources with the given IDs.
    * @throws {QueryError} If no resource is found with any of the given IDs.
    */
@@ -164,10 +164,12 @@ export class Client implements AsyncTermSearcher<string, string, Resource> {
   /**
    * Retrieves the parents of the resources with the given IDs.
    *
-   * @param ids the IDs of the resources whose parents to retrieve
-   * @param options additional options for the retrieval
-   * @param options.includeSchema whether to include the schema of the parents in the results
-   * @param options.excludeFieldData whether to exclude the field data of the parents in the results
+   * @param ids - the IDs of the resources whose parents to retrieve
+   * @param options - additional options for the retrieval
+   * @param options.includeSchema - whether to include the schema of the parents in the
+   * results
+   * @param options.excludeFieldData - whether to exclude the field data of the parents
+   * in the results
    * @returns the parents of the resources with the given IDs
    */
   async retrieveParents(
@@ -179,8 +181,8 @@ export class Client implements AsyncTermSearcher<string, string, Resource> {
 
   /**
    * Adds children to a resource in the ontology.
-   * @param id The ID of the resource to add children to.
-   * @param children The IDs of the children to add.
+   * @param id - The ID of the resource to add children to.
+   * @param children - The IDs of the children to add.
    */
   async addChildren(id: CrudeID, ...children: CrudeID[]): Promise<void> {
     return await this.writer.addChildren(id, ...children);
@@ -188,9 +190,8 @@ export class Client implements AsyncTermSearcher<string, string, Resource> {
 
   /**
    * Removes children from a resource in the ontology.
-   * @param id The ID of the resource to remove children from.
-   * @param children The IDs of the children
-   * to remove.
+   * @param id - The ID of the resource to remove children from.
+   * @param children - The IDs of the children to remove.
    */
   async removeChildren(id: CrudeID, ...children: CrudeID[]): Promise<void> {
     return await this.writer.removeChildren(id, ...children);
@@ -198,9 +199,9 @@ export class Client implements AsyncTermSearcher<string, string, Resource> {
 
   /**
    * Moves children from one resource to another in the ontology.
-   * @param from The ID of the resource to move children from.
-   * @param to The ID of the resource to move children to.
-   * @param children The IDs of the children to move.
+   * @param from - The ID of the resource to move children from.
+   * @param to - The ID of the resource to move children to.
+   * @param children - The IDs of the children to move.
    */
   async moveChildren(
     from: CrudeID,
@@ -294,7 +295,7 @@ export class ChangeTracker {
     }
   }
 
-  private async update(frame: Frame): Promise<void> {
+  private async update(frame: framer.Frame): Promise<void> {
     const resSets = await this.parseResourceSets(frame);
     const resDeletes = this.parseResourceDeletes(frame);
     const allResources = resSets.concat(resDeletes);
@@ -306,7 +307,7 @@ export class ChangeTracker {
       this.relationshipObs.notify(relSets.concat(relDeletes));
   }
 
-  private parseRelationshipSets(frame: Frame): RelationshipChange[] {
+  private parseRelationshipSets(frame: framer.Frame): RelationshipChange[] {
     const relationships = frame.get(RELATIONSHIP_SET_NAME);
     if (relationships.length === 0) return [];
     return Array.from(relationships.as("string")).map((rel) => ({
@@ -316,7 +317,7 @@ export class ChangeTracker {
     }));
   }
 
-  private parseRelationshipDeletes(frame: Frame): RelationshipChange[] {
+  private parseRelationshipDeletes(frame: framer.Frame): RelationshipChange[] {
     const relationships = frame.get(RELATIONSHIP_DELETE_NAME);
     if (relationships.length === 0) return [];
     return Array.from(relationships.as("string")).map((rel) => ({
@@ -325,7 +326,7 @@ export class ChangeTracker {
     }));
   }
 
-  private async parseResourceSets(frame: Frame): Promise<ResourceChange[]> {
+  private async parseResourceSets(frame: framer.Frame): Promise<ResourceChange[]> {
     const sets = frame.get(RESOURCE_SET_NAME);
     if (sets.length === 0) return [];
     // We should only ever get one series of sets
@@ -343,7 +344,7 @@ export class ChangeTracker {
     }
   }
 
-  private parseResourceDeletes(frame: Frame): ResourceChange[] {
+  private parseResourceDeletes(frame: framer.Frame): ResourceChange[] {
     const deletes = frame.get(RESOURCE_DELETE_NAME);
     if (deletes.length === 0) return [];
     // We should only ever get one series of deletes

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;
+  }
+}