@synnaxlabs/client 0.48.0 → 0.49.2

package/src/{hardware/rack → rack}/payload.ts

@@ -13,8 +13,8 @@ import { z } from "zod";
 export const keyZ = z.uint32();
 export type Key = z.infer<typeof keyZ>;
 
-export const statusDetailsSchema = z.object({ rack: keyZ });
-export const statusZ = status.statusZ(statusDetailsSchema);
+export const statusDetailsZ = z.object({ rack: keyZ });
+export const statusZ = status.statusZ(statusDetailsZ);
 
 export interface Status extends z.infer<typeof statusZ> {}
 

package/src/{hardware/rack → rack}/rack.spec.ts

@@ -7,10 +7,11 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+import { TimeStamp } from "@synnaxlabs/x";
 import { describe, expect, it } from "vitest";
 import { ZodError } from "zod";
 
-import { type rack } from "@/hardware/rack";
+import { type rack } from "@/rack";
 import { createTestClient } from "@/testutil/client";
 
 const client = createTestClient();
@@ -18,55 +19,80 @@ const client = createTestClient();
 describe("Rack", () => {
   describe("create", () => {
     it("should create a single rack", async () => {
-      const r = await client.hardware.racks.create({ name: "test" });
+      const r = await client.racks.create({ name: "test" });
       expect(r.key).toBeGreaterThan(0n);
     });
     it("should return an error if the rack doesn't have a name", async () => {
       // @ts-expect-error - Testing for error
-      await expect(client.hardware.racks.create({})).rejects.toThrow(ZodError);
+      await expect(client.racks.create({})).rejects.toThrow(ZodError);
+    });
+    it("should create a rack with a custom status", async () => {
+      const customStatus: rack.Status = {
+        key: "",
+        name: "",
+        variant: "success",
+        message: "Custom rack status",
+        description: "Rack is running",
+        time: TimeStamp.now(),
+        details: { rack: 0 },
+      };
+      const r = await client.racks.create({
+        name: "rack-with-status",
+        status: customStatus,
+      });
+      expect(r.key).toBeGreaterThan(0n);
+      const retrieved = await client.racks.retrieve({
+        key: r.key,
+        includeStatus: true,
+      });
+      expect(retrieved.status).toBeDefined();
+      expect(retrieved.status?.variant).toBe("success");
+      expect(retrieved.status?.message).toBe("Custom rack status");
+      expect(retrieved.status?.description).toBe("Rack is running");
+      expect(retrieved.status?.details?.rack).toBe(r.key);
     });
   });
   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({
+      const r = await client.racks.create({ name: "test" });
+      const updated = await client.racks.create({
         key: r.key,
         name: "updated",
       });
       expect(updated.name).toBe("updated");
-      const retrieved = await client.hardware.racks.retrieve({ key: r.key });
+      const retrieved = await client.racks.retrieve({ key: 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" });
-      const retrieved = await client.hardware.racks.retrieve({ key: r.key });
+      const r = await client.racks.create({ name: "test" });
+      const retrieved = await client.racks.retrieve({ key: r.key });
       expect(retrieved.key).toBe(r.key);
       expect(retrieved.name).toBe("test");
     });
     it("should retrieve a rack by its name", async () => {
-      const name = `TimeStamp.now().toString()}-${Math.random()}`;
-      const r = await client.hardware.racks.create({ name });
-      const retrieved = await client.hardware.racks.retrieve({ name });
+      const name = `${TimeStamp.now().toString()}-${Math.random()}`;
+      const r = await client.racks.create({ name });
+      const retrieved = await client.racks.retrieve({ name });
       expect(retrieved.key).toBe(r.key);
       expect(retrieved.name).toEqual(name);
     });
   });
   describe("tasks", () => {
     it("should list the tasks on a rack", async () => {
-      const r = await client.hardware.racks.create({ name: "test" });
+      const r = await client.racks.create({ name: "test" });
       const tasks = await r.listTasks();
       expect(tasks).toHaveLength(0);
     });
   });
   describe("status", () => {
     it("should include the rack's status when includeStatus is true", async () => {
-      const r = await client.hardware.racks.create({ name: "test" });
+      const r = await client.racks.create({ name: "test" });
       let status: rack.Status | undefined;
       await expect
         .poll(async () => {
-          const retrieved = await client.hardware.racks.retrieve({
+          const retrieved = await client.racks.retrieve({
             key: r.key,
             includeStatus: true,
           });
@@ -77,12 +103,12 @@ describe("Rack", () => {
       expect(status?.details?.rack).toBe(r.key);
     });
     it("should include the status for multiple racks", async () => {
-      const r1 = await client.hardware.racks.create({ name: "test1" });
-      const r2 = await client.hardware.racks.create({ name: "test2" });
+      const r1 = await client.racks.create({ name: "test1" });
+      const r2 = await client.racks.create({ name: "test2" });
       let statuses: (rack.Status | undefined)[] = [];
       await expect
         .poll(async () => {
-          const retrieved = await client.hardware.racks.retrieve({
+          const retrieved = await client.racks.retrieve({
             keys: [r1.key, r2.key],
             includeStatus: true,
           });

package/src/ranger/access.spec.ts

@@ -0,0 +1,115 @@
+// Copyright 2025 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 { TimeRange } from "@synnaxlabs/x";
+import { describe, expect, it } from "vitest";
+
+import { AuthError, NotFoundError } from "@/errors";
+import { ranger } from "@/ranger";
+import { createTestClientWithPolicy } from "@/testutil/access";
+import { createTestClient } from "@/testutil/client";
+
+const client = createTestClient();
+
+describe("range", () => {
+  describe("access control", () => {
+    it("should deny access when no retrieve policy exists", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [],
+        actions: [],
+      });
+      const randomRange = await client.ranges.create({
+        name: "test",
+        timeRange: new TimeRange(1n, 1000n),
+        color: "#E774D0",
+      });
+      await expect(userClient.ranges.retrieve(randomRange.key)).rejects.toThrow(
+        AuthError,
+      );
+    });
+
+    it("should allow the caller to retrieve ranges with the correct policy", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [ranger.ontologyID("")],
+        actions: ["retrieve"],
+      });
+      const randomRange = await client.ranges.create({
+        name: "test",
+        timeRange: new TimeRange(1n, 1000n),
+        color: "#E774D0",
+      });
+      const retrieved = await userClient.ranges.retrieve(randomRange.key);
+      expect(retrieved.key).toBe(randomRange.key);
+      expect(retrieved.name).toBe(randomRange.name);
+    });
+
+    it("should allow the caller to create ranges with the correct policy", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [ranger.ontologyID("")],
+        actions: ["create"],
+      });
+      await userClient.ranges.create({
+        name: "test",
+        timeRange: new TimeRange(1n, 1000n),
+        color: "#E774D0",
+      });
+    });
+
+    it("should deny access when no create policy exists", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [ranger.ontologyID("")],
+        actions: [],
+      });
+      await expect(
+        userClient.ranges.create({
+          name: "test",
+          timeRange: new TimeRange(1n, 1000n),
+          color: "#E774D0",
+        }),
+      ).rejects.toThrow(AuthError);
+    });
+
+    it("should allow the caller to delete ranges with the correct policy", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [ranger.ontologyID("")],
+        actions: ["delete"],
+      });
+      const randomRange = await client.ranges.create({
+        name: "test",
+        timeRange: new TimeRange(1n, 1000n),
+        color: "#E774D0",
+      });
+      await userClient.ranges.delete(randomRange.key);
+      await expect(userClient.ranges.retrieve(randomRange.key)).rejects.toThrow(
+        NotFoundError,
+      );
+    });
+
+    it("should deny access when no delete policy exists", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [ranger.ontologyID("")],
+        actions: [],
+      });
+      const randomRange = await client.ranges.create({
+        name: "test",
+        timeRange: new TimeRange(1n, 1000n),
+        color: "#E774D0",
+      });
+      await expect(userClient.ranges.delete(randomRange.key)).rejects.toThrow(
+        AuthError,
+      );
+    });
+  });
+});

package/src/ranger/alias.ts

@@ -12,7 +12,6 @@ import { array, type change } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { channel } from "@/channel";
-import { type framer } from "@/framer";
 import { type Key, keyZ } from "@/ranger/payload";
 
 export const SET_ALIAS_CHANNEL_NAME = "sy_range_alias_set";
@@ -39,21 +38,14 @@ const retrieveReqZ = z.object({ range: keyZ, channels: channel.keyZ.array() });
 const retrieveResZ = 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 RETRIEVE_ENDPOINT = "/range/alias/retrieve";
-  private static readonly DELETE_ENDPOINT = "/range/alias/delete";
-  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: framer.Client, client: UnaryClient) {
+  constructor(rangeKey: Key, client: UnaryClient) {
     this.rangeKey = rangeKey;
     this.cache = new Map();
     this.client = client;
-    this.frameClient = frameClient;
   }
 
   resolve(aliases: string): Promise<channel.Key>;
@@ -79,7 +71,7 @@ export class Aliaser {
     if (toFetch.length === 0) return cached;
     const res = await sendRequired<typeof resolveReqZ, typeof resolveResZ>(
       this.client,
-      Aliaser.RESOLVE_ENDPOINT,
+      "/range/alias/resolve",
       { range: this.rangeKey, aliases: toFetch },
       resolveReqZ,
       resolveResZ,
@@ -91,7 +83,7 @@ export class Aliaser {
   async set(aliases: Record<channel.Key, string>): Promise<void> {
     await sendRequired<typeof setReqZ, typeof setResZ>(
       this.client,
-      Aliaser.SET_ENDPOINT,
+      "/range/alias/set",
       { range: this.rangeKey, aliases },
       setReqZ,
       setResZ,
@@ -102,7 +94,7 @@ export class Aliaser {
     return (
       await sendRequired<typeof listReqZ, typeof listResZ>(
         this.client,
-        Aliaser.LIST_ENDPOINT,
+        "/range/alias/list",
         { range: this.rangeKey },
         listReqZ,
         listResZ,
@@ -119,7 +111,7 @@ export class Aliaser {
     const isSingle = typeof alias === "number";
     const res = await sendRequired<typeof retrieveReqZ, typeof retrieveResZ>(
       this.client,
-      Aliaser.RETRIEVE_ENDPOINT,
+      "/range/alias/retrieve",
       { range: this.rangeKey, channels: array.toArray(alias) },
       retrieveReqZ,
       retrieveResZ,
@@ -130,7 +122,7 @@ export class Aliaser {
   async delete(aliases: channel.Key | channel.Key[]): Promise<void> {
     await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
       this.client,
-      Aliaser.DELETE_ENDPOINT,
+      "/range/alias/delete",
       { range: this.rangeKey, channels: array.toArray(aliases) },
       deleteReqZ,
       deleteResZ,

package/src/ranger/client.ts

@@ -15,7 +15,7 @@ import { type channel } from "@/channel";
 import { QueryError } from "@/errors";
 import { type framer } from "@/framer";
 import { label } from "@/label";
-import { type ontology } from "@/ontology";
+import { ontology } from "@/ontology";
 import { Aliaser } from "@/ranger/alias";
 import { KV } from "@/ranger/kv";
 import {
@@ -163,12 +163,12 @@ export class Range {
 
 const retrieveRequestZ = z.object({
   keys: keyZ.array().optional(),
-  names: z.array(z.string()).optional(),
+  names: z.string().array().optional(),
   searchTerm: z.string().optional(),
   overlapsWith: TimeRange.z.optional(),
-  limit: z.number().int().optional(),
-  offset: z.number().int().optional(),
   hasLabels: label.keyZ.array().optional(),
+  limit: z.int().optional(),
+  offset: z.int().optional(),
   includeLabels: z.boolean().optional(),
   includeParent: z.boolean().optional(),
 });
@@ -189,8 +189,6 @@ const retrieveArgsZ = retrieveRequestZ
 
 export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
 
-const RETRIEVE_ENDPOINT = "/range/retrieve";
-
 const retrieveResZ = z.object({ ranges: array.nullableZ(payloadZ) });
 
 export class Client {
@@ -244,7 +242,7 @@ export class Client {
     const isSingle = typeof params === "string";
     const { ranges } = await sendRequired(
       this.unaryClient,
-      RETRIEVE_ENDPOINT,
+      "/range/retrieve",
       params,
       retrieveArgsZ,
       retrieveResZ,
@@ -271,7 +269,7 @@ export class Client {
   }
 
   async retrieveAlias(range: Key, channel: channel.Key): Promise<string> {
-    const aliaser = new Aliaser(range, this.frameClient, this.unaryClient);
+    const aliaser = new Aliaser(range, this.unaryClient);
     return await aliaser.retrieve(channel);
   }
 
@@ -279,22 +277,22 @@ export class Client {
     range: Key,
     channels: channel.Key[],
   ): Promise<Record<channel.Key, string>> {
-    const aliaser = new Aliaser(range, this.frameClient, this.unaryClient);
+    const aliaser = new Aliaser(range, this.unaryClient);
     return await aliaser.retrieve(channels);
   }
 
   async listAliases(range: Key): Promise<Record<channel.Key, string>> {
-    const aliaser = new Aliaser(range, this.frameClient, this.unaryClient);
+    const aliaser = new Aliaser(range, this.unaryClient);
     return await aliaser.list();
   }
 
   async setAlias(range: Key, channel: channel.Key, alias: string): Promise<void> {
-    const aliaser = new Aliaser(range, this.frameClient, this.unaryClient);
+    const aliaser = new Aliaser(range, this.unaryClient);
     await aliaser.set({ [channel]: alias });
   }
 
   async deleteAlias(range: Key, channels: channel.Key | channel.Key[]): Promise<void> {
-    const aliaser = new Aliaser(range, this.frameClient, this.unaryClient);
+    const aliaser = new Aliaser(range, this.unaryClient);
     await aliaser.delete(channels);
   }
 
@@ -302,7 +300,7 @@ export class Client {
     return new Range(payload, {
       frameClient: this.frameClient,
       kv: new KV(payload.key, this.unaryClient),
-      aliaser: new Aliaser(payload.key, this.frameClient, this.unaryClient),
+      aliaser: new Aliaser(payload.key, this.unaryClient),
       channels: this.channels,
       labelClient: this.labelClient,
       ontologyClient: this.ontologyClient,
@@ -326,7 +324,8 @@ export class Client {
   }
 }
 
-export const ontologyID = (key: Key): ontology.ID => ({ type: "range", key });
+export const ontologyID = ontology.createIDFactory<Key>("range");
+export const TYPE_ONTOLOGY_ID = ontologyID("");
 
 export const aliasOntologyID = (key: Key): ontology.ID => ({
   type: "range-alias",

package/src/ranger/kv.ts

@@ -8,7 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { array, isObject } from "@synnaxlabs/x";
+import { array } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { type Key, keyZ } from "@/ranger/payload";
@@ -34,9 +34,6 @@ const deleteReqZ = z.object({ range: keyZ, keys: z.string().array() });
 export interface DeleteRequest extends z.infer<typeof deleteReqZ> {}
 
 export class KV {
-  private static readonly GET_ENDPOINT = "/range/kv/get";
-  private static readonly SET_ENDPOINT = "/range/kv/set";
-  private static readonly DELETE_ENDPOINT = "/range/kv/delete";
   private readonly rangeKey: Key;
   private readonly client: UnaryClient;
 
@@ -50,7 +47,7 @@ export class KV {
   async get(keys: string | string[]): Promise<string | Record<string, string>> {
     const res = await sendRequired(
       this.client,
-      KV.GET_ENDPOINT,
+      "/range/kv/get",
       { range: this.rangeKey, keys: array.toArray(keys) },
       getReqZ,
       getResZ,
@@ -67,16 +64,17 @@ export class KV {
   async set(kv: Record<string, string>): Promise<void>;
   async set(key: string | Record<string, string>, value: string = ""): Promise<void> {
     let pairs: KVPair[];
-    if (isObject(key))
+    if (typeof key == "string") pairs = [{ range: this.rangeKey, key, value }];
+    else
       pairs = Object.entries(key).map(([k, v]) => ({
         range: this.rangeKey,
         key: k,
         value: v,
       }));
-    else pairs = [{ range: this.rangeKey, key, value }];
+
     await sendRequired(
       this.client,
-      KV.SET_ENDPOINT,
+      "/range/kv/set",
       { range: this.rangeKey, pairs },
       setReqZ,
       z.unknown(),
@@ -86,7 +84,7 @@ export class KV {
   async delete(key: string | string[]): Promise<void> {
     await sendRequired(
       this.client,
-      KV.DELETE_ENDPOINT,
+      "/range/kv/delete",
       { range: this.rangeKey, keys: array.toArray(key) },
       deleteReqZ,
       z.unknown(),

package/src/ranger/ranger.spec.ts

@@ -7,7 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { DataType, math, TimeSpan, TimeStamp, uuid } from "@synnaxlabs/x";
+import { DataType, id, math, TimeSpan, TimeStamp, uuid } from "@synnaxlabs/x";
 import { describe, expect, it } from "vitest";
 
 import { NotFoundError } from "@/errors";
@@ -284,7 +284,7 @@ describe("Ranger", () => {
     describe("set + resolve", () => {
       it("should set and resolve an alias for the range", async () => {
         const ch = await client.channels.create({
-          name: "My New Channel",
+          name: id.create(),
           dataType: DataType.FLOAT32,
           virtual: true,
         });
@@ -300,7 +300,7 @@ describe("Ranger", () => {
     describe("deleteAlias", () => {
       it("should remove an alias for the range", async () => {
         const ch = await client.channels.create({
-          name: "My New Channel",
+          name: id.create(),
           dataType: DataType.FLOAT32,
           virtual: true,
         });
@@ -316,7 +316,7 @@ describe("Ranger", () => {
     describe("list", () => {
       it("should list the aliases for the range", async () => {
         const ch = await client.channels.create({
-          name: "My New Channel",
+          name: id.create(),
           dataType: DataType.FLOAT32,
           virtual: true,
         });

package/src/ranger/writer.ts

@@ -26,10 +26,6 @@ const deleteResZ = z.object({});
 const renameReqZ = z.object({ key: keyZ, name: nameZ });
 const renameResZ = z.object({});
 
-const CREATE_ENDPOINT = "/range/create";
-const DELETE_ENDPOINT = "/range/delete";
-const RENAME_ENDPOINT = "/range/rename";
-
 export class Writer {
   client: UnaryClient;
 
@@ -40,7 +36,7 @@ export class Writer {
   async rename(key: string, name: string): Promise<void> {
     await sendRequired<typeof renameReqZ, typeof renameResZ>(
       this.client,
-      RENAME_ENDPOINT,
+      "/range/rename",
       { key, name },
       renameReqZ,
       renameResZ,
@@ -50,7 +46,7 @@ export class Writer {
   async create(ranges: New[], options?: CreateOptions): Promise<Payload[]> {
     const res = await sendRequired<typeof createReqZ, typeof createResZ>(
       this.client,
-      CREATE_ENDPOINT,
+      "/range/create",
       { ranges, ...options },
       createReqZ,
       createResZ,
@@ -61,7 +57,7 @@ export class Writer {
   async delete(keys: string[]): Promise<void> {
     await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
       this.client,
-      DELETE_ENDPOINT,
+      "/range/delete",
       { keys },
       deleteReqZ,
       deleteResZ,

package/src/status/access.spec.ts

@@ -0,0 +1,129 @@
+// Copyright 2025 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 { TimeStamp, uuid } from "@synnaxlabs/x";
+import { describe, expect, it } from "vitest";
+
+import { AuthError, NotFoundError } from "@/errors";
+import { status } from "@/status";
+import { createTestClientWithPolicy } from "@/testutil/access";
+import { createTestClient } from "@/testutil/client";
+
+const client = createTestClient();
+
+describe("status", () => {
+  describe("access control", () => {
+    it("should deny access when no retrieve policy exists", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [],
+        actions: [],
+      });
+      const randomStatus = await client.statuses.set({
+        name: "test",
+        key: uuid.create(),
+        variant: "info",
+        message: "test",
+        time: TimeStamp.now(),
+      });
+      await expect(
+        userClient.statuses.retrieve({ key: randomStatus.key }),
+      ).rejects.toThrow(AuthError);
+    });
+
+    it("should allow the caller to retrieve statuses with the correct policy", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [status.ontologyID("")],
+        actions: ["retrieve"],
+      });
+      const randomStatus = await client.statuses.set({
+        name: "test",
+        key: uuid.create(),
+        variant: "info",
+        message: "test",
+        time: TimeStamp.now(),
+      });
+      const retrieved = await userClient.statuses.retrieve({
+        key: randomStatus.key,
+      });
+      expect(retrieved.key).toBe(randomStatus.key);
+      expect(retrieved.name).toBe(randomStatus.name);
+    });
+
+    it("should allow the caller to set statuses with the correct policy", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [status.ontologyID("")],
+        actions: ["create"],
+      });
+      await userClient.statuses.set({
+        name: "test",
+        key: uuid.create(),
+        variant: "info",
+        message: "test",
+        time: TimeStamp.now(),
+      });
+    });
+
+    it("should deny access when no create policy exists", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [status.ontologyID("")],
+        actions: [],
+      });
+      await expect(
+        userClient.statuses.set({
+          name: "test",
+          key: uuid.create(),
+          variant: "info",
+          message: "test",
+          time: TimeStamp.now(),
+        }),
+      ).rejects.toThrow(AuthError);
+    });
+
+    it("should allow the caller to delete statuses with the correct policy", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [status.ontologyID("")],
+        actions: ["delete", "retrieve"],
+      });
+      const randomStatus = await client.statuses.set({
+        name: "test",
+        key: uuid.create(),
+        variant: "info",
+        message: "test",
+        time: TimeStamp.now(),
+      });
+      await userClient.statuses.delete(randomStatus.key);
+      await expect(
+        userClient.statuses.retrieve({ key: randomStatus.key }),
+      ).rejects.toThrow(NotFoundError);
+    });
+
+    it("should deny access when no delete policy exists", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [status.ontologyID("")],
+        actions: [],
+      });
+      const randomStatus = await client.statuses.set({
+        name: "test",
+        key: uuid.create(),
+        variant: "info",
+        message: "test",
+        time: TimeStamp.now(),
+      });
+      await expect(userClient.statuses.delete(randomStatus.key)).rejects.toThrow(
+        AuthError,
+      );
+    });
+  });
+});