@synnaxlabs/client 0.48.0 → 0.49.2

package/src/label/access.spec.ts

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

package/src/label/client.ts

@@ -36,18 +36,13 @@ export interface SetOptions extends Pick<SetReq, "replace"> {}
 const removeReqZ = setReqZ.omit({ replace: true });
 const emptyResZ = z.object({});
 
-const CREATE_ENDPOINT = "/label/create";
-const DELETE_ENDPOINT = "/label/delete";
-const SET_ENDPOINT = "/label/set";
-const REMOVE_ENDPOINT = "/label/remove";
-const RETRIEVE_ENDPOINT = "/label/retrieve";
-
 const retrieveRequestZ = z.object({
   keys: keyZ.array().optional(),
+  names: z.string().array().optional(),
   for: ontology.idZ.optional(),
   searchTerm: z.string().optional(),
-  offset: z.number().optional(),
-  limit: z.number().optional(),
+  offset: z.int().optional(),
+  limit: z.int().optional(),
 });
 
 const singleRetrieveArgsZ = z
@@ -76,7 +71,7 @@ export class Client {
     const isSingle = "key" in args;
     const res = await sendRequired(
       this.client,
-      RETRIEVE_ENDPOINT,
+      "/label/retrieve",
       args,
       retrieveArgsZ,
       retrieveResponseZ,
@@ -88,7 +83,7 @@ export class Client {
   async label(id: ontology.ID, labels: Key[], opts: SetOptions = {}): Promise<void> {
     await sendRequired<typeof setReqZ, typeof emptyResZ>(
       this.client,
-      SET_ENDPOINT,
+      "/label/set",
       { id, labels, replace: opts.replace },
       setReqZ,
       emptyResZ,
@@ -98,7 +93,7 @@ export class Client {
   async remove(id: ontology.ID, labels: Key[]): Promise<void> {
     await sendRequired<typeof removeReqZ, typeof emptyResZ>(
       this.client,
-      REMOVE_ENDPOINT,
+      "/label/remove",
       { id, labels },
       removeReqZ,
       emptyResZ,
@@ -111,7 +106,7 @@ export class Client {
     const isMany = Array.isArray(labels);
     const res = await sendRequired<typeof createReqZ, typeof createResZ>(
       this.client,
-      CREATE_ENDPOINT,
+      "/label/create",
       { labels: array.toArray(labels) },
       createReqZ,
       createResZ,
@@ -122,7 +117,7 @@ export class Client {
   async delete(keys: Key | Key[]): Promise<void> {
     await sendRequired<typeof deleteReqZ, typeof emptyResZ>(
       this.client,
-      DELETE_ENDPOINT,
+      "/label/delete",
       { keys: array.toArray(keys) },
       deleteReqZ,
       emptyResZ,
@@ -130,4 +125,5 @@ export class Client {
   }
 }
 
-export const ontologyID = (key: Key): ontology.ID => ({ type: "label", key });
+export const ontologyID = ontology.createIDFactory<Key>("label");
+export const TYPE_ONTOLOGY_ID = ontologyID("");

package/src/ontology/client.ts

@@ -25,17 +25,15 @@ import {
 } from "@/ontology/payload";
 import { Writer } from "@/ontology/writer";
 
-const RETRIEVE_ENDPOINT = "/ontology/retrieve";
-
 const retrieveReqZ = z.object({
   ids: idZ.array().optional(),
   children: z.boolean().optional(),
   parents: z.boolean().optional(),
   excludeFieldData: z.boolean().optional(),
-  searchTerm: z.string().optional(),
-  limit: z.number().optional(),
-  offset: z.number().optional(),
   types: resourceTypeZ.array().optional(),
+  searchTerm: z.string().optional(),
+  limit: z.int().optional(),
+  offset: z.int().optional(),
 });
 export interface RetrieveRequest extends z.infer<typeof retrieveReqZ> {}
 
@@ -174,7 +172,7 @@ export class Client {
   private async execRetrieve(request: RetrieveRequest): Promise<Resource[]> {
     const { resources } = await sendRequired(
       this.client,
-      RETRIEVE_ENDPOINT,
+      "/ontology/retrieve",
       request,
       retrieveReqZ,
       retrieveResZ,

package/src/ontology/group/access.spec.ts

@@ -0,0 +1,77 @@
+// 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 { id } from "@synnaxlabs/x";
+import { describe, expect, it } from "vitest";
+
+import { AuthError } from "@/errors";
+import { ontology } from "@/ontology";
+import { group } from "@/ontology/group";
+import { createTestClientWithPolicy } from "@/testutil/access";
+import { createTestClient } from "@/testutil/client";
+
+const client = createTestClient();
+
+describe("group", () => {
+  describe("access control", () => {
+    it("should allow the caller to create groups with the correct policy", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [group.ontologyID("")],
+        actions: ["create"],
+      });
+      await userClient.ontology.groups.create({
+        parent: ontology.ROOT_ID,
+        name: `test-${id.create()}`,
+      });
+    });
+
+    it("should deny access when no create policy exists", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [group.ontologyID("")],
+        actions: [],
+      });
+      await expect(
+        userClient.ontology.groups.create({
+          parent: ontology.ROOT_ID,
+          name: `test-${id.create()}`,
+        }),
+      ).rejects.toThrow(AuthError);
+    });
+
+    it("should allow the caller to delete groups with the correct policy", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [group.ontologyID("")],
+        actions: ["delete", "retrieve"],
+      });
+      const randomGroup = await client.ontology.groups.create({
+        parent: ontology.ROOT_ID,
+        name: `test-${id.create()}`,
+      });
+      await userClient.ontology.groups.delete(randomGroup.key);
+    });
+
+    it("should deny access when no delete policy exists", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [group.ontologyID("")],
+        actions: [],
+      });
+      const randomGroup = await client.ontology.groups.create({
+        parent: ontology.ROOT_ID,
+        name: `test-${id.create()}`,
+      });
+      await expect(userClient.ontology.groups.delete(randomGroup.key)).rejects.toThrow(
+        AuthError,
+      );
+    });
+  });
+});

package/src/ontology/group/client.ts

@@ -29,10 +29,6 @@ const renameReqZ = z.object({ key: keyZ, name: z.string() });
 
 const deleteReqZ = z.object({ keys: z.array(keyZ) });
 
-const CREATE_ENDPOINT = "/ontology/create-group";
-const RENAME_ENDPOINT = "/ontology/rename-group";
-const DELETE_ENDPOINT = "/ontology/delete-group";
-
 export interface CreateArgs extends z.infer<typeof createReqZ> {}
 
 export class Client {
@@ -45,7 +41,7 @@ export class Client {
   async create(args: CreateArgs): Promise<Group> {
     const res = await sendRequired(
       this.client,
-      CREATE_ENDPOINT,
+      "/ontology/create-group",
       args,
       createReqZ,
       resZ,
@@ -56,7 +52,7 @@ export class Client {
   async rename(key: Key, name: string): Promise<void> {
     await sendRequired(
       this.client,
-      RENAME_ENDPOINT,
+      "/ontology/rename-group",
       { key, name },
       renameReqZ,
       z.object({}),
@@ -66,7 +62,7 @@ export class Client {
   async delete(keys: Key | Key[]): Promise<void> {
     await sendRequired(
       this.client,
-      DELETE_ENDPOINT,
+      "/ontology/delete-group",
       { keys: array.toArray(keys) },
       deleteReqZ,
       z.object({}),

package/src/ontology/group/group.spec.ts

@@ -7,6 +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 { id } from "@synnaxlabs/x";
 import { describe, expect, it } from "vitest";
 
 import { NotFoundError } from "@/errors";
@@ -23,6 +24,23 @@ describe("Group", () => {
       const g = await client.ontology.groups.create({ parent: ontology.ROOT_ID, name });
       expect(g.name).toEqual(name);
     });
+    it("should update an existing group", async () => {
+      const parent = await client.ontology.groups.create({
+        parent: ontology.ROOT_ID,
+        name: `test-parent-key${id.create()}`,
+      });
+      const g = await client.ontology.groups.create({
+        parent: group.ontologyID(parent.key),
+        name: `original-name-${id.create()}`,
+      });
+      await client.ontology.groups.create({
+        parent: group.ontologyID(parent.key),
+        key: g.key,
+        name: "updated-name",
+      });
+      const g2 = await client.ontology.retrieve(group.ontologyID(g.key));
+      expect(g2.name).toEqual("updated-name");
+    });
   });
   describe("rename", () => {
     it("should correctly rename a group", async () => {

package/src/ontology/group/payload.ts

@@ -9,7 +9,7 @@
 
 import { z } from "zod";
 
-import { type ID as OntologyID } from "@/ontology/payload";
+import { createIDFactory } from "@/ontology/payload";
 
 export const keyZ = z.uuid();
 export type Key = z.infer<typeof keyZ>;
@@ -21,4 +21,4 @@ export type Params = Key | Name | Keys | Names;
 export const groupZ = z.object({ key: keyZ, name: nameZ });
 export interface Group extends z.infer<typeof groupZ> {}
 
-export const ontologyID = (key: Key): OntologyID => ({ type: "group", key });
+export const ontologyID = createIDFactory("group");

package/src/ontology/ontology.spec.ts

@@ -202,11 +202,13 @@ describe("Ontology", () => {
       });
       const oldRootLength = (await client.ontology.retrieveChildren(ontology.ROOT_ID))
         .length;
+
       await client.ontology.moveChildren(
         ontology.ROOT_ID,
         group.ontologyID(g.key),
         group.ontologyID(g2.key),
       );
+
       const children = await client.ontology.retrieveChildren(group.ontologyID(g.key));
       expect(children.length).toEqual(1);
       const newRootLength = (await client.ontology.retrieveChildren(ontology.ROOT_ID))

package/src/ontology/payload.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 { array, type change, record } from "@synnaxlabs/x";
+import { array, type change, primitive, record } from "@synnaxlabs/x";
 import { z } from "zod";
 
 export type ResourceChange = change.Change<ID, Resource>;
@@ -22,7 +22,6 @@ export interface RelationshipDelete extends change.Delete<Relationship, undefine
 export const resourceTypeZ = z.enum([
   "label",
   "log",
-  "allow_all",
   "builtin",
   "cluster",
   "channel",
@@ -39,6 +38,7 @@ export const resourceTypeZ = z.enum([
   "device",
   "task",
   "policy",
+  "role",
   "table",
   "arc",
   "schematic_symbol",
@@ -57,6 +57,22 @@ export type ID = z.infer<typeof idZ>;
 
 export const ROOT_ID: ID = { type: "builtin", key: "root" };
 
+export interface CreateID<K extends record.Key> {
+  (key: K): ID;
+  (keys: K[]): ID[];
+  (keys: K | K[]): ID | ID[];
+}
+
+export const createIDFactory = <K extends record.Key>(
+  type: ResourceType,
+): CreateID<K> => {
+  const id = (key: K) => ({ type, key: primitive.isZero(key) ? "" : key.toString() });
+  return ((key: K | K[]) => {
+    if (Array.isArray(key)) return key.map(id);
+    return id(key);
+  }) as CreateID<K>;
+};
+
 export interface IDToString {
   (id: ID | string): string;
   (ids: (ID | string)[]): string[];

package/src/ontology/writer.ts

@@ -12,10 +12,6 @@ import { z } from "zod";
 
 import { type ID, idZ } from "@/ontology/payload";
 
-const ADD_CHILDREN_ENDPOINT = "/ontology/add-children";
-const REMOVE_CHILDREN_ENDPOINT = "/ontology/remove-children";
-const MOVE_CHILDREN_ENDPOINT = "/ontology/move-children";
-
 export const addRemoveChildrenReqZ = z.object({ id: idZ, children: idZ.array() });
 export const moveChildrenReqZ = z.object({ from: idZ, to: idZ, children: idZ.array() });
 export const emptyResZ = z.object({});
@@ -30,7 +26,7 @@ export class Writer {
   async addChildren(id: ID, ...children: ID[]): Promise<void> {
     await sendRequired<typeof addRemoveChildrenReqZ, typeof emptyResZ>(
       this.client,
-      ADD_CHILDREN_ENDPOINT,
+      "/ontology/add-children",
       { id, children },
       addRemoveChildrenReqZ,
       emptyResZ,
@@ -40,7 +36,7 @@ export class Writer {
   async removeChildren(id: ID, ...children: ID[]): Promise<void> {
     await sendRequired<typeof addRemoveChildrenReqZ, typeof emptyResZ>(
       this.client,
-      REMOVE_CHILDREN_ENDPOINT,
+      "/ontology/remove-children",
       { id, children },
       addRemoveChildrenReqZ,
       emptyResZ,
@@ -50,7 +46,7 @@ export class Writer {
   async moveChildren(from: ID, to: ID, ...children: ID[]): Promise<void> {
     await sendRequired<typeof moveChildrenReqZ, typeof emptyResZ>(
       this.client,
-      MOVE_CHILDREN_ENDPOINT,
+      "/ontology/move-children",
       { from, to, children },
       moveChildrenReqZ,
       emptyResZ,

package/src/rack/access.spec.ts

@@ -0,0 +1,102 @@
+// 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 { describe, expect, it } from "vitest";
+
+import { AuthError, NotFoundError } from "@/errors";
+import { rack } from "@/rack";
+import { createTestClientWithPolicy } from "@/testutil/access";
+import { createTestClient } from "@/testutil/client";
+
+const client = createTestClient();
+
+describe("rack", () => {
+  describe("access control", () => {
+    it("should deny access when no retrieve policy exists", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [],
+        actions: [],
+      });
+      const randomRack = await client.racks.create({
+        name: "test",
+      });
+      await expect(userClient.racks.retrieve({ key: randomRack.key })).rejects.toThrow(
+        AuthError,
+      );
+    });
+
+    it("should allow the caller to retrieve racks with the correct policy", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [rack.ontologyID(0)],
+        actions: ["retrieve"],
+      });
+      const randomRack = await client.racks.create({
+        name: "test",
+      });
+      const retrieved = await userClient.racks.retrieve({
+        key: randomRack.key,
+      });
+      expect(retrieved.key).toBe(randomRack.key);
+      expect(retrieved.name).toBe(randomRack.name);
+    });
+
+    it("should allow the caller to create racks with the correct policy", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [rack.ontologyID(0)],
+        actions: ["create"],
+      });
+      await userClient.racks.create({
+        name: "test",
+      });
+    });
+
+    it("should deny access when no create policy exists", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [rack.ontologyID(0)],
+        actions: [],
+      });
+      await expect(
+        userClient.racks.create({
+          name: "test",
+        }),
+      ).rejects.toThrow(AuthError);
+    });
+
+    it("should allow the caller to delete racks with the correct policy", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [rack.ontologyID(0)],
+        actions: ["delete", "retrieve"],
+      });
+      const randomRack = await client.racks.create({
+        name: "test",
+      });
+      await userClient.racks.delete(randomRack.key);
+      await expect(userClient.racks.retrieve({ key: randomRack.key })).rejects.toThrow(
+        NotFoundError,
+      );
+    });
+
+    it("should deny access when no delete policy exists", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [rack.ontologyID(0)],
+        actions: [],
+      });
+      const randomRack = await client.racks.create({
+        name: "test",
+      });
+      await expect(userClient.racks.delete(randomRack.key)).rejects.toThrow(AuthError);
+    });
+  });
+});

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

@@ -11,6 +11,7 @@ import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { array } from "@synnaxlabs/x";
 import { z } from "zod";
 
+import { ontology } from "@/ontology";
 import {
   type Key,
   keyZ,
@@ -19,16 +20,10 @@ import {
   type Payload,
   rackZ,
   type Status,
-} from "@/hardware/rack/payload";
-import { type task } from "@/hardware/task";
-import { type ontology } from "@/ontology";
+} from "@/rack/payload";
+import { type task } from "@/task";
 import { checkForMultipleOrNoResults } from "@/util/retrieve";
 
-const RETRIEVE_ENDPOINT = "/hardware/rack/retrieve";
-const CREATE_ENDPOINT = "/hardware/rack/create";
-const DELETE_ENDPOINT = "/hardware/rack/delete";
-
-export const STATUS_CHANNEL_NAME = "sy_rack_status";
 export const SET_CHANNEL_NAME = "sy_rack_set";
 export const DELETE_CHANNEL_NAME = "sy_rack_delete";
 
@@ -38,8 +33,8 @@ const retrieveReqZ = z.object({
   searchTerm: z.string().optional(),
   embedded: z.boolean().optional(),
   hostIsNode: z.boolean().optional(),
-  limit: z.number().optional(),
-  offset: z.number().optional(),
+  limit: z.int().optional(),
+  offset: z.int().optional(),
   includeStatus: z.boolean().optional(),
 });
 const retrieveResZ = z.object({ racks: array.nullableZ(rackZ) });
@@ -86,7 +81,7 @@ export class Client {
   async delete(keys: Key | Key[]): Promise<void> {
     await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
       this.client,
-      DELETE_ENDPOINT,
+      "/rack/delete",
       { keys: array.toArray(keys) },
       deleteReqZ,
       deleteResZ,
@@ -99,7 +94,7 @@ export class Client {
     const isSingle = !Array.isArray(rack);
     const res = await sendRequired<typeof createReqZ, typeof createResZ>(
       this.client,
-      CREATE_ENDPOINT,
+      "/rack/create",
       { racks: array.toArray(rack) },
       createReqZ,
       createResZ,
@@ -114,7 +109,7 @@ export class Client {
     const isSingle = "key" in args || "name" in args;
     const res = await sendRequired(
       this.client,
-      RETRIEVE_ENDPOINT,
+      "/rack/retrieve",
       args,
       retrieveArgsZ,
       retrieveResZ,
@@ -158,7 +153,7 @@ export class Rack {
     Config extends z.ZodType = z.ZodType,
     StatusData extends z.ZodType = z.ZodType,
   >(
-    task: task.New<Type, Config>,
+    task: task.New<Type, Config, StatusData>,
     schemas: task.Schemas<Type, Config, StatusData>,
   ): Promise<task.Task<Type, Config, StatusData>>;
 
@@ -167,7 +162,7 @@ export class Rack {
     Config extends z.ZodType = z.ZodType,
     StatusData extends z.ZodType = z.ZodType,
   >(
-    task: task.New<Type, Config>,
+    task: task.New<Type, Config, StatusData>,
     schemas?: task.Schemas<Type, Config, StatusData>,
   ): Promise<task.Task<Type, Config, StatusData>> {
     task.key = (
@@ -189,7 +184,7 @@ export class Rack {
   }
 }
 
-export const ontologyID = (key: Key): ontology.ID => ({
-  type: "rack",
-  key: key.toString(),
-});
+export const ontologyID = ontology.createIDFactory<Key>("rack");
+export const TYPE_ONTOLOGY_ID = ontologyID(0);
+
+export const statusKey = (key: Key): string => ontology.idToString(ontologyID(key));

package/src/{hardware/device/index.ts → rack/external.ts}

@@ -7,4 +7,5 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export * as device from "@/hardware/device/external";
+export * from "@/rack/client";
+export * from "@/rack/payload";

package/src/{hardware/external.ts → rack/index.ts}

@@ -7,4 +7,4 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export * from "@/hardware/client";
+export * as rack from "@/rack/external";