@synnaxlabs/client 0.53.0 → 0.54.0

package/src/task/client.ts

@@ -21,7 +21,7 @@ import { z } from "zod";
 
 import { type framer } from "@/framer";
 import { ontology } from "@/ontology";
-import { keyZ as rackKeyZ } from "@/rack/payload";
+import { type Key as RackKey, keyZ as rackKeyZ } from "@/rack/types.gen";
 import { type ranger } from "@/ranger";
 import { status } from "@/status";
 import {
@@ -29,20 +29,28 @@ import {
   keyZ,
   type New,
   newZ,
+  ontologyID,
   type Payload,
-  type Schemas,
+  type PayloadSchemas as Schemas,
+  payloadZ,
   type Status,
   statusZ,
-  taskZ,
-} from "@/task/payload";
+} from "@/task/types.gen";
 import { checkForMultipleOrNoResults } from "@/util/retrieve";
 
+export type { PayloadSchemas as Schemas } from "@/task/types.gen";
+
 export const COMMAND_CHANNEL_NAME = "sy_task_cmd";
 export const SET_CHANNEL_NAME = "sy_task_set";
 export const DELETE_CHANNEL_NAME = "sy_task_delete";
 
 const NOT_CREATED_ERROR = new Error("Task not created");
 
+export const rackKey = (key: Key): RackKey => Number(BigInt(key) >> 32n);
+
+export const newKey = (rackKey: RackKey, taskKey: number = 0): Key =>
+  ((BigInt(rackKey) << 32n) + BigInt(taskKey)).toString();
+
 const retrieveSnapshottedTo = async (taskKey: Key, ontologyClient: ontology.Client) => {
   const parents = await ontologyClient.retrieveParents(ontologyID(taskKey));
   if (parents.length === 0) return null;
@@ -119,10 +127,10 @@ export class Task<S extends Schemas = Schemas> {
     this.schemas =
       schemas ??
       ({
-        type: z.string() as unknown as S["type"],
-        config: z.unknown() as S["config"],
-        statusData: z.unknown() as S["statusData"],
-      } as S);
+        type: z.string(),
+        config: z.unknown(),
+        statusData: z.unknown(),
+      } as unknown as S);
     this.internal = internal;
     this.snapshot = snapshot;
     this.status = status;
@@ -212,10 +220,7 @@ const singleRetrieveArgsZ = z.union([
     .object({ name: z.string(), includeStatus: z.boolean().optional() })
     .transform(({ name, includeStatus }) => ({ names: [name], includeStatus })),
   z
-    .object({
-      type: z.string(),
-      rack: rackKeyZ.optional(),
-    })
+    .object({ type: z.string(), rack: rackKeyZ.optional() })
     .transform(({ type, rack }) => ({ types: [type], rack })),
 ]);
 export type RetrieveSingleParams = z.input<typeof singleRetrieveArgsZ>;
@@ -231,19 +236,19 @@ interface RetrieveSchemas<S extends Schemas = Schemas> {
 }
 
 const retrieveResZ = <S extends Schemas = Schemas>(schemas?: S) =>
-  z.object({ tasks: array.nullableZ(taskZ(schemas)) });
+  z.object({ tasks: array.nullishToEmpty(payloadZ(schemas)) });
 
 export interface RetrieveRequest extends z.infer<typeof retrieveReqZ> {}
 
 const createReqZ = <S extends Schemas = Schemas>(schemas?: S) =>
   z.object({ tasks: newZ(schemas).array() });
 const createResZ = <S extends Schemas = Schemas>(schemas?: S) =>
-  z.object({ tasks: taskZ(schemas).array() });
+  z.object({ tasks: payloadZ(schemas).array() });
 const deleteReqZ = z.object({ keys: keyZ.array() });
 const deleteResZ = z.object({});
 const copyReqZ = z.object({ key: keyZ, name: z.string(), snapshot: z.boolean() });
 const copyResZ = <S extends Schemas = Schemas>(schemas?: S) =>
-  z.object({ task: taskZ(schemas) });
+  z.object({ task: payloadZ(schemas) });
 
 export class Client {
   private readonly client: UnaryClient;
@@ -323,7 +328,7 @@ export class Client {
     return isSingle ? sugared[0] : sugared;
   }
 
-  async copy(key: string, name: string, snapshot: boolean): Promise<Task> {
+  async copy(key: Key, name: string, snapshot: boolean): Promise<Task> {
     const copyRes = copyResZ();
     const response = await sendRequired(
       this.client,
@@ -332,7 +337,7 @@ export class Client {
       copyReqZ,
       copyRes,
     );
-    return this.sugar(response.task as Payload);
+    return this.sugar(response.task);
   }
 
   async list(rack?: number): Promise<Task[]> {
@@ -388,15 +393,15 @@ export class Client {
     return await executeCommand({ ...params, frameClient: this.frameClient });
   }
 
-  async executeCommandSync<StatusData extends z.ZodType = z.ZodType>(
+  async executeCommandSync<StatusData extends z.ZodType = z.ZodNever>(
     params: ExecuteCommandsSyncParams<StatusData>,
   ): Promise<Status<StatusData>[]>;
 
-  async executeCommandSync<StatusData extends z.ZodType = z.ZodType>(
+  async executeCommandSync<StatusData extends z.ZodType = z.ZodNever>(
     params: ExecuteCommandSyncParams<StatusData>,
   ): Promise<Status<StatusData>>;
 
-  async executeCommandSync<StatusData extends z.ZodType = z.ZodType>(
+  async executeCommandSync<StatusData extends z.ZodType = z.ZodNever>(
     params:
       | ExecuteCommandsSyncParams<StatusData>
       | ExecuteCommandSyncParams<StatusData>,
@@ -426,9 +431,6 @@ export class Client {
   }
 }
 
-export const ontologyID = ontology.createIDFactory<Key>("task");
-export const TYPE_ONTOLOGY_ID = ontologyID("");
-
 export const statusKey = (key: Key): string => ontology.idToString(ontologyID(key));
 
 interface ExecuteCommandInternalParams {
@@ -469,14 +471,14 @@ const executeCommands = async ({
   return cmds.map((c) => c.key);
 };
 
-interface ExecuteCommandSyncInternalParams<StatusData extends z.ZodType = z.ZodType>
+interface ExecuteCommandSyncInternalParams<StatusData extends z.ZodType = z.ZodNever>
   extends
     Omit<ExecuteCommandsSyncInternalParams<StatusData>, "commands">,
     TaskExecuteCommandSyncParams {
   task: Key;
 }
 
-const executeCommandSync = async <StatusData extends z.ZodType = z.ZodType>({
+const executeCommandSync = async <StatusData extends z.ZodType = z.ZodNever>({
   frameClient,
   task,
   type,
@@ -495,7 +497,7 @@ const executeCommandSync = async <StatusData extends z.ZodType = z.ZodType>({
     })
   )[0];
 
-interface ExecuteCommandsSyncInternalParams<StatusData extends z.ZodType = z.ZodType> {
+interface ExecuteCommandsSyncInternalParams<StatusData extends z.ZodType = z.ZodNever> {
   frameClient: framer.Client | null;
   commands: NewCommand[];
   timeout?: CrudeTimeSpan;
@@ -503,7 +505,7 @@ interface ExecuteCommandsSyncInternalParams<StatusData extends z.ZodType = z.Zod
   name: string | string[] | (() => Promise<string | string[]>);
 }
 
-const executeCommandsSync = async <StatusData extends z.ZodType = z.ZodType>({
+const executeCommandsSync = async <StatusData extends z.ZodType = z.ZodNever>({
   frameClient,
   commands,
   timeout = TimeSpan.seconds(10),
@@ -562,7 +564,7 @@ const formatTimeoutError = async (
   } catch (e) {
     console.error("Failed to retrieve task name for timeout error:", e);
     return new Error(
-      `${formattedType} command to task with key ${strings.naturalLanguageJoin(key)} timed out after ${formattedTimeout}`,
+      `${formattedType} command to task with key ${strings.naturalLanguageJoin(array.toArray(key).map((k) => k.toString()))} timed out after ${formattedTimeout}`,
     );
   }
 };

package/src/task/external.ts

@@ -8,4 +8,4 @@
 // included in the file licenses/APL.txt.
 
 export * from "@/task/client";
-export * from "@/task/payload";
+export * from "@/task/types.gen";

package/src/task/payload.spec.ts

@@ -9,7 +9,7 @@
 
 import { describe, expect, it } from "vitest";
 
-import { newKey, rackKey } from "@/task/payload";
+import { task } from "@/task";
 
 describe("newKey", () => {
   describe("basic key generation", () => {
@@ -24,7 +24,7 @@ describe("newKey", () => {
     ];
     cases.forEach(({ rackKey: r, taskKey: t, expected }) => {
       it(`should combine rackKey=${r} and taskKey=${t}`, () => {
-        expect(newKey(r, t)).toBe(expected);
+        expect(task.newKey(r, t)).toBe(expected);
       });
     });
   });
@@ -34,7 +34,7 @@ describe("newKey", () => {
     const rackKeys = [0, 1, 42, 1000];
     rackKeys.forEach((r) => {
       it(`should default taskKey to 0 for rackKey=${r}`, () => {
-        expect(newKey(r)).toBe(newKey(r, 0));
+        expect(task.newKey(r)).toBe(task.newKey(r, 0));
       });
     });
   });
@@ -49,10 +49,10 @@ describe("newKey", () => {
       { rack: 100, task: 50000 },
       { rack: 2147483647, task: 2147483647 }, // max 32-bit signed integers
     ];
-    cases.forEach(({ rack, task }) => {
-      it(`should extract rack=${rack} from key generated with task=${task}`, () => {
-        const key = newKey(rack, task);
-        expect(rackKey(key)).toBe(rack);
+    cases.forEach(({ rack, task: tsk }) => {
+      it(`should extract rack=${rack} from key generated with task=${tsk}`, () => {
+        const key = task.newKey(rack, tsk);
+        expect(task.rackKey(key)).toBe(rack);
       });
     });
   });
@@ -61,22 +61,22 @@ describe("newKey", () => {
     // Verifies behavior at boundary values to ensure no overflow or precision issues.
     it("should handle max 32-bit unsigned rack key", () => {
       const maxUint32 = 0xffffffff;
-      const key = newKey(maxUint32, 0);
-      expect(rackKey(key)).toBe(maxUint32);
+      const key = task.newKey(maxUint32, 0);
+      expect(task.rackKey(key)).toBe(maxUint32);
     });
 
     it("should handle max 32-bit unsigned task key", () => {
       const maxUint32 = 0xffffffff;
-      const key = newKey(1, maxUint32);
+      const key = task.newKey(1, maxUint32);
       expect(key).toBe(((1n << 32n) + BigInt(maxUint32)).toString());
     });
 
     it("should handle both max 32-bit values", () => {
       const maxUint32 = 0xffffffff;
-      const key = newKey(maxUint32, maxUint32);
+      const key = task.newKey(maxUint32, maxUint32);
       const expected = ((BigInt(maxUint32) << 32n) + BigInt(maxUint32)).toString();
       expect(key).toBe(expected);
-      expect(rackKey(key)).toBe(maxUint32);
+      expect(task.rackKey(key)).toBe(maxUint32);
     });
   });
 });
@@ -86,28 +86,28 @@ describe("rackKey", () => {
   // Keys can be string, bigint, or number per keyZ schema.
   describe("key format handling", () => {
     const rack = 42;
-    const task = 100;
-    const expectedKey = newKey(rack, task);
+    const tsk = 100;
+    const expectedKey = task.newKey(rack, tsk);
 
     it("should extract rack from string key", () => {
-      expect(rackKey(expectedKey)).toBe(rack);
+      expect(task.rackKey(expectedKey)).toBe(rack);
     });
 
     it("should extract rack from numeric string", () => {
       const numericKey = ((42n << 32n) + 100n).toString();
-      expect(rackKey(numericKey)).toBe(42);
+      expect(task.rackKey(numericKey)).toBe(42);
     });
   });
 
   describe("zero handling", () => {
     // Verifies correct behavior when rack or task portions are zero.
     it("should return 0 for key with zero rack", () => {
-      expect(rackKey("100")).toBe(0);
+      expect(task.rackKey("100")).toBe(0);
     });
 
     it("should return rack when task portion is zero", () => {
-      const key = newKey(5, 0);
-      expect(rackKey(key)).toBe(5);
+      const key = task.newKey(5, 0);
+      expect(task.rackKey(key)).toBe(5);
     });
   });
 });

package/src/task/task.spec.ts

@@ -9,6 +9,7 @@
 
 import { TimeStamp } from "@synnaxlabs/x";
 import { beforeAll, describe, expect, it } from "vitest";
+import { z } from "zod";
 
 import { ontology } from "@/ontology";
 import { task } from "@/task";
@@ -46,17 +47,20 @@ describe("Task", async () => {
       expect(m.config).toStrictEqual(config);
     });
     it("should create a task with a custom status", async () => {
+      const customStatus = {
+        key: "",
+        name: "",
+        variant: "success" as const,
+        message: "Custom task status",
+        description: "Task is running",
+        time: TimeStamp.now(),
+        details: { running: true, data: { customData: true } },
+      };
       const m = await testRack.createTask({
         name: "task-with-status",
         config: { test: true },
         type: "ni",
-        status: {
-          variant: "success",
-          message: "Custom task status",
-          description: "Task is running",
-          time: TimeStamp.now(),
-          details: { running: true, data: { customData: true } },
-        },
+        status: customStatus,
       });
       expect(m.key).not.toHaveLength(0);
       const retrieved = await client.tasks.retrieve({
@@ -78,8 +82,10 @@ describe("Task", async () => {
         config: { a: "dog" },
         type: "ni",
       });
+      // Exclude status, internal, snapshot when updating - these have different input/output types
+      const { status: _, internal: __, snapshot: ___, ...taskFields } = m;
       const updated = await client.tasks.create({
-        ...m,
+        ...taskFields,
         name: "updated",
       });
       expect(updated.name).toBe("updated");
@@ -119,7 +125,7 @@ describe("Task", async () => {
           key: ontology.idToString(task.ontologyID(t.key)),
           name: "test",
           variant: "success",
-          details: { task: t.key, running: false, data: {} },
+          details: { task: t.key, running: false, data: undefined },
           message: "test",
           time: TimeStamp.now(),
         };
@@ -522,4 +528,116 @@ describe("Task", async () => {
       );
     });
   });
+
+  describe("with schemas", () => {
+    const schemas = {
+      type: z.literal("sensor_task"),
+      config: z.object({
+        sampleRate: z.number(),
+        channels: z.array(z.string()),
+        enabled: z.boolean(),
+      }),
+      statusData: z.object({
+        samplesCollected: z.number().optional(),
+      }),
+    };
+
+    it("should create and retrieve a task with typed config", async () => {
+      const config = {
+        sampleRate: 1000,
+        channels: ["ch1", "ch2"],
+        enabled: true,
+      };
+      const t = await testRack.createTask(
+        {
+          name: "typed-config-task",
+          type: "sensor_task",
+          config,
+        },
+        schemas,
+      );
+      expect(t.config.sampleRate).toBe(1000);
+      expect(t.config.channels).toEqual(["ch1", "ch2"]);
+      expect(t.config.enabled).toBe(true);
+
+      const retrieved = await client.tasks.retrieve({
+        key: t.key,
+        schemas,
+      });
+      expect(retrieved.config.sampleRate).toBe(1000);
+      expect(retrieved.config.channels).toEqual(["ch1", "ch2"]);
+      expect(retrieved.type).toBe("sensor_task");
+    });
+
+    it("should retrieve multiple tasks with schemas", async () => {
+      const t1 = await testRack.createTask(
+        {
+          name: "multi-schema-1",
+          type: "sensor_task",
+          config: { sampleRate: 100, channels: ["a"], enabled: true },
+        },
+        schemas,
+      );
+      const t2 = await testRack.createTask(
+        {
+          name: "multi-schema-2",
+          type: "sensor_task",
+          config: { sampleRate: 200, channels: ["b", "c"], enabled: false },
+        },
+        schemas,
+      );
+
+      const retrieved = await client.tasks.retrieve({
+        keys: [t1.key, t2.key],
+        schemas,
+      });
+      expect(retrieved).toHaveLength(2);
+      expect(retrieved[0].config.sampleRate).toBe(100);
+      expect(retrieved[1].config.sampleRate).toBe(200);
+    });
+
+    it("should retrieve task by name with schemas", async () => {
+      const uniqueName = `schema-name-test-${Date.now()}`;
+      await testRack.createTask(
+        {
+          name: uniqueName,
+          type: "sensor_task",
+          config: { sampleRate: 500, channels: ["x"], enabled: true },
+        },
+        schemas,
+      );
+
+      const retrieved = await client.tasks.retrieve({
+        name: uniqueName,
+        schemas,
+      });
+      expect(retrieved.name).toBe(uniqueName);
+      expect(retrieved.config.sampleRate).toBe(500);
+    });
+
+    it("should retrieve task by type with schemas", async () => {
+      const customSchemas = {
+        type: z.literal("unique_type_test"),
+        config: z.object({ value: z.number() }),
+        statusData: z.unknown(),
+      };
+
+      await testRack.createTask(
+        {
+          name: "type-filter-test",
+          type: "unique_type_test",
+          config: { value: 42 },
+        },
+        customSchemas,
+      );
+
+      const retrieved = await client.tasks.retrieve({
+        type: "unique_type_test",
+        rack: testRack.key,
+        schemas: customSchemas,
+      });
+      expect(retrieved.type).toBe("unique_type_test");
+      expect(retrieved.config.value).toBe(42);
+    });
+  });
 });

package/src/task/types.gen.ts

@@ -0,0 +1,169 @@
+// Copyright 2026 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.
+
+// Code generated by Oracle. DO NOT EDIT.
+
+import { caseconv, type optional, record, status, zod } from "@synnaxlabs/x";
+import { z } from "zod";
+
+import { ontology } from "@/ontology";
+
+export const keyZ = z
+  .string()
+  .or(z.number().transform(String).or(z.bigint().transform(String)));
+export type Key = z.infer<typeof keyZ>;
+
+export type StatusDetailsZodObject<Data extends z.ZodType = z.ZodNever> = z.ZodObject<{
+  task: typeof keyZ;
+  running: z.ZodBoolean;
+  cmd: z.ZodOptional<z.ZodString>;
+  data: [Data] extends [z.ZodNever] ? z.ZodOptional<z.ZodUnknown> : Data;
+}>;
+
+export interface StatusDetailsZFunction {
+  <Data extends z.ZodType>(data: Data): StatusDetailsZodObject<Data>;
+  <Data extends z.ZodType = z.ZodNever>(data?: Data): StatusDetailsZodObject<Data>;
+}
+
+export const statusDetailsZ: StatusDetailsZFunction = <Data extends z.ZodType>(
+  data?: Data,
+) =>
+  z.object({
+    task: keyZ,
+    running: z.boolean(),
+    cmd: z.string().optional(),
+    data: data ?? z.unknown().optional(),
+  });
+export type StatusDetails<Data extends z.ZodType = z.ZodNever> = {
+  task: Key;
+  running: boolean;
+  cmd?: string;
+} & ([Data] extends [z.ZodNever] ? {} : { data: z.infer<Data> });
+
+export type NewStatusDetailsZodObject<Data extends z.ZodType = z.ZodNever> =
+  z.ZodObject<{
+    task: z.ZodOptional<typeof keyZ>;
+    running: z.ZodBoolean;
+    cmd: z.ZodOptional<z.ZodString>;
+    data: [Data] extends [z.ZodNever] ? z.ZodOptional<z.ZodUnknown> : Data;
+  }>;
+
+export interface NewStatusDetailsZFunction {
+  <Data extends z.ZodType>(data: Data): NewStatusDetailsZodObject<Data>;
+  <Data extends z.ZodType = z.ZodNever>(data?: Data): NewStatusDetailsZodObject<Data>;
+}
+
+export const newStatusDetailsZ: NewStatusDetailsZFunction = <Data extends z.ZodType>(
+  data?: Data,
+) =>
+  z.object({
+    task: keyZ.optional(),
+    running: z.boolean(),
+    cmd: z.string().optional(),
+    data: data ?? z.unknown().optional(),
+  });
+export type NewStatusDetails<Data extends z.ZodType = z.ZodNever> = {
+  task?: Key;
+  running: boolean;
+  cmd?: string;
+} & ([Data] extends [z.ZodNever] ? {} : { data: z.infer<Data> });
+
+/** Command is a command to execute on a task in the Driver system. */
+export const commandZ = z.object({
+  /** task is the key of the target task. */
+  task: keyZ,
+  /** type is the command type (e.g., 'start', 'stop', 'configure'). */
+  type: z.string(),
+  /** key is a unique identifier for this command instance. */
+  key: z.string(),
+  /** args contains optional arguments for the command. */
+  args: caseconv.preserveCase(zod.nullToUndefined(record.unknownZ())),
+});
+export interface Command extends z.infer<typeof commandZ> {}
+
+export const statusZ = <Data extends z.ZodType = z.ZodNever>(data?: Data) =>
+  status.statusZ({ details: statusDetailsZ(data) });
+export type Status<Data extends z.ZodType = z.ZodNever> = z.infer<
+  ReturnType<typeof statusZ<Data>>
+>;
+
+export const newStatusZ = <Data extends z.ZodType = z.ZodNever>(data?: Data) =>
+  status.newZ({ details: newStatusDetailsZ(data) });
+export type NewStatus<Data extends z.ZodType = z.ZodNever> = z.infer<
+  ReturnType<typeof newStatusZ<Data>>
+>;
+
+export interface PayloadSchemas<
+  Type extends z.ZodType<string> = z.ZodType<string>,
+  Config extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
+  StatusData extends z.ZodType = z.ZodType,
+> {
+  type: Type;
+  config: Config;
+  statusData: StatusData;
+}
+
+export const payloadZ = <
+  Type extends z.ZodType<string> = z.ZodString,
+  Config extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
+  StatusData extends z.ZodType = z.ZodNever,
+>({
+  type,
+  config,
+  statusData,
+}: Partial<PayloadSchemas<Type, Config, StatusData>> = {}) =>
+  z.object({
+    key: keyZ,
+    name: z.string(),
+    type: type ?? z.string(),
+    config: config ?? record.nullishToEmpty(),
+    internal: z.boolean().optional(),
+    snapshot: z.boolean().optional(),
+    status: status.statusZ({ details: statusDetailsZ(statusData) }).optional(),
+  });
+export interface Payload<S extends PayloadSchemas = PayloadSchemas> {
+  key: Key;
+  name: string;
+  type: z.infer<S["type"]>;
+  config: z.infer<S["config"]>;
+  internal?: boolean;
+  snapshot?: boolean;
+  status?: Status<S["statusData"]>;
+}
+
+export interface NewSchemas<
+  Type extends z.ZodType<string> = z.ZodType<string>,
+  Config extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
+  StatusData extends z.ZodType = z.ZodType,
+> {
+  type: Type;
+  config: Config;
+  statusData: StatusData;
+}
+
+export const newZ = <
+  Type extends z.ZodType<string> = z.ZodString,
+  Config extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
+  StatusData extends z.ZodType = z.ZodNever,
+>({ type, config, statusData }: Partial<NewSchemas<Type, Config, StatusData>> = {}) =>
+  payloadZ({ type, config, statusData })
+    .omit({ internal: true, snapshot: true, status: true })
+    .partial({ key: true })
+    .extend({
+      status: status.newZ({ details: newStatusDetailsZ(statusData) }).optional(),
+    });
+export type New<S extends NewSchemas = NewSchemas> = optional.Optional<
+  Omit<Payload<S>, "internal" | "snapshot" | "status">,
+  "key"
+> & {
+  status?: NewStatus<S["statusData"]>;
+};
+
+export const ontologyID = ontology.createIDFactory<Key>("task");
+export const TYPE_ONTOLOGY_ID = ontologyID("");

package/src/user/client.ts

@@ -13,7 +13,7 @@ import { z } from "zod";
 
 import { MultipleFoundError, NotFoundError } from "@/errors";
 import { ontology } from "@/ontology";
-import { type Key, keyZ, type New, newZ, type User, userZ } from "@/user/payload";
+import { type Key, keyZ, type New, newZ, type User, userZ } from "@/user/types.gen";
 
 const retrieveRequestZ = z.object({
   keys: keyZ.array().optional(),
@@ -53,7 +53,7 @@ export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
 
 export interface RetrieveRequest extends z.infer<typeof retrieveRequestZ> {}
 
-const retrieveResZ = z.object({ users: array.nullableZ(userZ) });
+const retrieveResZ = z.object({ users: array.nullishToEmpty(userZ) });
 
 const createReqZ = z.object({ users: newZ.array() });
 const createResZ = z.object({ users: userZ.array() });

package/src/user/external.ts

@@ -19,4 +19,4 @@ export {
   type UsernameRetrieveRequest,
   type UsernamesRetrieveRequest,
 } from "@/user/client";
-export * from "@/user/payload";
+export * from "@/user/types.gen";