@synnaxlabs/client 0.38.1 → 0.40.0

package/src/util/retrieve.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 { describe, expect,it } from "vitest";
+import { describe, expect, it } from "vitest";
 import { type Primitive } from "zod";
 
 import {
@@ -28,22 +28,12 @@ describe("retrieve utils", () => {
       {
         args: "abc",
         variantMap: { string: "name" },
-        expected: {
-          single: true,
-          variant: "name",
-          normalized: ["abc"],
-          actual: "abc",
-        },
+        expected: { single: true, variant: "name", normalized: ["abc"], actual: "abc" },
       },
       {
         args: 123,
         variantMap: { number: "id" },
-        expected: {
-          single: true,
-          variant: "id",
-          normalized: [123],
-          actual: 123,
-        },
+        expected: { single: true, variant: "id", normalized: [123], actual: 123 },
       },
     ];
 

package/src/util/retrieve.ts

@@ -15,24 +15,14 @@ export type SingleParamAnalysisResult<
   T extends Primitive,
   K extends PartialTypeNameRecord<T>,
 > = T extends any
-  ? {
-      single: true;
-      variant: K[keyof K];
-      normalized: T[];
-      actual: T;
-    }
+  ? { single: true; variant: K[keyof K]; normalized: T[]; actual: T }
   : never;
 
 export type MultiParamAnalysisResult<
   T extends Primitive,
   K extends PartialTypeNameRecord<T>,
 > = T extends any
-  ? {
-      single: false;
-      variant: K[keyof K];
-      normalized: T[];
-      actual: T[];
-    }
+  ? { single: false; variant: K[keyof K]; normalized: T[]; actual: T[] }
   : never;
 
 type TypeName<T> = T extends string

package/src/util/telem.ts

@@ -10,7 +10,7 @@
 import { type DataType, type TypedArray } from "@synnaxlabs/x/telem";
 
 export const randomSeries = (length: number, dataType: DataType): TypedArray => {
-  // generate random bytes of the correct length
+  // create random bytes of the correct length
   const bytes = new Uint8Array(length * dataType.density.valueOf());
   for (let i = 0; i < bytes.byteLength; i++) bytes[i] = Math.floor(Math.random() * 256);
   return new dataType.Array(bytes.buffer);

package/src/vite-env.d.ts

@@ -8,4 +8,5 @@
 // included in the file licenses/APL.txt.
 
 /// <reference types="vite/client" />
+
 declare const __VERSION__: string;

package/src/workspace/client.ts

@@ -9,77 +9,52 @@
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { toArray, type UnknownRecord } from "@synnaxlabs/x";
-import { unknownRecordZ } from "@synnaxlabs/x/record";
 import { type AsyncTermSearcher } from "@synnaxlabs/x/search";
 import { z } from "zod";
 
 import { ontology } from "@/ontology";
+import { type Key as UserKey, keyZ as userKeyZ } from "@/user/payload";
 import { nullableArrayZ } from "@/util/zod";
 import { linePlot } from "@/workspace/lineplot";
 import { log } from "@/workspace/log";
+import {
+  type Key,
+  keyZ,
+  type New,
+  newZ,
+  ONTOLOGY_TYPE,
+  type Params,
+  remoteZ,
+  type Workspace,
+  workspaceZ,
+} from "@/workspace/payload";
 import { schematic } from "@/workspace/schematic";
 import { table } from "@/workspace/table";
 
-export const keyZ = z.string().uuid();
-export type Key = z.infer<typeof keyZ>;
-export type Params = Key | Key[];
-
-// --- VERY IMPORTANT ---
-// Synnax's encoders (in the binary package inside x) automatically convert the case
-// of keys in objects to snake_case and back to camelCase when encoding and decoding
-// respectively. This is done to ensure that the keys are consistent across all
-// languages and platforms. Sometimes workspaces have keys that are uuids, which have
-// dashes, and those get messed up. So we just use regular JSON for workspaces.
-const parse = (s: string): UnknownRecord => JSON.parse(s) as UnknownRecord;
-
-export const workspaceZ = z.object({
-  key: z.string(),
-  name: z.string(),
-  layout: unknownRecordZ.or(z.string().transform((s) => parse(s))),
-});
-
-export type Workspace = z.infer<typeof workspaceZ>;
-
-export const ONTOLOGY_TYPE: ontology.ResourceType = "workspace";
-
-export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key });
-
 const RETRIEVE_ENDPOINT = "/workspace/retrieve";
 const CREATE_ENDPOINT = "/workspace/create";
 const RENAME_ENDPOINT = "/workspace/rename";
 const SET_LAYOUT_ENDPOINT = "/workspace/set-layout";
 const DELETE_ENDPOINT = "/workspace/delete";
 
-export const newWorkspaceZ = workspaceZ.partial({ key: true }).transform((p) => ({
-  ...p,
-  layout: JSON.stringify(p.layout),
-}));
-
-export const workspaceRemoteZ = workspaceZ.omit({ layout: true }).extend({
-  layout: z.string().transform((s) => parse(s)),
-});
-
-export type NewWorkspace = z.input<typeof newWorkspaceZ>;
-
 const retrieveReqZ = z.object({
-  keys: z.string().array().optional(),
+  keys: keyZ.array().optional(),
   search: z.string().optional(),
-  author: z.string().uuid().optional(),
+  author: userKeyZ.optional(),
   offset: z.number().optional(),
   limit: z.number().optional(),
 });
-const createReqZ = z.object({ workspaces: newWorkspaceZ.array() });
-const renameReqZ = z.object({ key: z.string(), name: z.string() });
-const setLayoutReqZ = z.object({ key: z.string(), layout: z.string() });
-const deleteReqZ = z.object({ keys: z.string().array() });
+const createReqZ = z.object({ workspaces: newZ.array() });
+const renameReqZ = z.object({ key: keyZ, name: z.string() });
+const setLayoutReqZ = z.object({ key: keyZ, layout: z.string() });
+const deleteReqZ = z.object({ keys: keyZ.array() });
 
 const retrieveResZ = z.object({ workspaces: nullableArrayZ(workspaceZ) });
-const createResZ = z.object({ workspaces: workspaceRemoteZ.array() });
+const createResZ = z.object({ workspaces: remoteZ.array() });
 const emptyResZ = z.object({});
 
 export class Client implements AsyncTermSearcher<string, Key, Workspace> {
-  readonly type = "workspace";
+  readonly type = ONTOLOGY_TYPE;
   readonly schematic: schematic.Client;
   readonly linePlot: linePlot.Client;
   readonly log: log.Client;
@@ -94,17 +69,14 @@ export class Client implements AsyncTermSearcher<string, Key, Workspace> {
     this.table = new table.Client(client);
   }
 
-  async create(workspace: NewWorkspace): Promise<Workspace>;
-  async create(workspaces: NewWorkspace[]): Promise<Workspace[]>;
-  async create(
-    workspaces: NewWorkspace | NewWorkspace[],
-  ): Promise<Workspace | Workspace[]> {
+  async create(workspace: New): Promise<Workspace>;
+  async create(workspaces: New[]): Promise<Workspace[]>;
+  async create(workspaces: New | New[]): Promise<Workspace | Workspace[]> {
     const isMany = Array.isArray(workspaces);
-    const normalized = toArray(workspaces);
     const res = await sendRequired(
       this.client,
       CREATE_ENDPOINT,
-      { workspaces: normalized },
+      { workspaces: toArray(workspaces) },
       createReqZ,
       createResZ,
     );
@@ -135,18 +107,17 @@ export class Client implements AsyncTermSearcher<string, Key, Workspace> {
   async retrieve(keys: Key[]): Promise<Workspace[]>;
   async retrieve(keys: Params): Promise<Workspace | Workspace[]> {
     const isMany = Array.isArray(keys);
-    const normalized = toArray(keys);
     const res = await sendRequired(
       this.client,
       RETRIEVE_ENDPOINT,
-      { keys: normalized },
+      { keys: toArray(keys) },
       retrieveReqZ,
       retrieveResZ,
     );
     return isMany ? res.workspaces : res.workspaces[0];
   }
 
-  async retrieveByAuthor(author: string): Promise<Workspace[]> {
+  async retrieveByAuthor(author: UserKey): Promise<Workspace[]> {
     const res = await sendRequired(
       this.client,
       RETRIEVE_ENDPOINT,
@@ -182,13 +153,15 @@ export class Client implements AsyncTermSearcher<string, Key, Workspace> {
   async delete(key: Key): Promise<void>;
   async delete(keys: Key[]): Promise<void>;
   async delete(keys: Params): Promise<void> {
-    const normalized = toArray(keys);
     await sendRequired(
       this.client,
       DELETE_ENDPOINT,
-      { keys: normalized },
+      { keys: toArray(keys) },
       deleteReqZ,
       emptyResZ,
     );
   }
 }
+
+export const ontologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });

package/src/workspace/external.ts

@@ -0,0 +1,11 @@
+// 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.
+
+export * from "@/workspace/client";
+export * from "@/workspace/payload";

package/src/workspace/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 * as workspace from "@/workspace/client";
+export * as workspace from "@/workspace/external";

package/src/workspace/lineplot/client.ts

@@ -9,28 +9,21 @@
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { toArray, type UnknownRecord } from "@synnaxlabs/x";
-import { unknownRecordZ } from "@synnaxlabs/x/record";
 import { z } from "zod";
 
 import { ontology } from "@/ontology";
 import { nullableArrayZ } from "@/util/zod";
-
-export const keyZ = z.string().uuid();
-export type Key = z.infer<typeof keyZ>;
-export type Params = Key | Key[];
-
-export const linePlotZ = z.object({
-  key: z.string(),
-  name: z.string(),
-  data: unknownRecordZ.or(z.string().transform((s) => JSON.parse(s) as UnknownRecord)),
-});
-
-export type LinePlot = z.infer<typeof linePlotZ>;
-
-export const ONTOLOGY_TYPE: ontology.ResourceType = "lineplot";
-
-export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key });
+import {
+  type Key,
+  keyZ,
+  type LinePlot,
+  linePlotZ,
+  type New,
+  newZ,
+  ONTOLOGY_TYPE,
+  type Params,
+} from "@/workspace/lineplot/payload";
+import { type Key as WorkspaceKey, keyZ as workspaceKeyZ } from "@/workspace/payload";
 
 const RETRIEVE_ENDPOINT = "/workspace/lineplot/retrieve";
 const CREATE_ENDPOINT = "/workspace/lineplot/create";
@@ -38,15 +31,8 @@ const RENAME_ENDPOINT = "/workspace/lineplot/rename";
 const SET_DATA_ENDPOINT = "/workspace/lineplot/set-data";
 const DELETE_ENDPOINT = "/workspace/lineplot/delete";
 
-export const newLinePlotZ = linePlotZ.partial({ key: true }).transform((p) => ({
-  ...p,
-  data: JSON.stringify(p.data),
-}));
-
-export type NewLinePlot = z.input<typeof newLinePlotZ>;
-
 const retrieveReqZ = z.object({ keys: keyZ.array() });
-const createReqZ = z.object({ workspace: z.string(), linePlots: newLinePlotZ.array() });
+const createReqZ = z.object({ workspace: workspaceKeyZ, linePlots: newZ.array() });
 const renameReqZ = z.object({ key: keyZ, name: z.string() });
 const setDataReqZ = z.object({ key: keyZ, data: z.string() });
 const deleteReqZ = z.object({ keys: keyZ.array() });
@@ -61,18 +47,17 @@ export class Client {
     this.client = client;
   }
 
-  async create(workspace: string, linePlot: NewLinePlot): Promise<LinePlot>;
-  async create(workspace: string, linePlots: NewLinePlot[]): Promise<LinePlot[]>;
+  async create(workspace: WorkspaceKey, linePlot: New): Promise<LinePlot>;
+  async create(workspace: WorkspaceKey, linePlots: New[]): Promise<LinePlot[]>;
   async create(
-    workspace: string,
-    linePlots: NewLinePlot | NewLinePlot[],
+    workspace: WorkspaceKey,
+    linePlots: New | New[],
   ): Promise<LinePlot | LinePlot[]> {
     const isMany = Array.isArray(linePlots);
-    const normalized = toArray(linePlots);
     const res = await sendRequired(
       this.client,
       CREATE_ENDPOINT,
-      { workspace, linePlots: normalized },
+      { workspace, linePlots: toArray(linePlots) },
       createReqZ,
       createResZ,
     );
@@ -103,11 +88,10 @@ export class Client {
   async retrieve(keys: Key[]): Promise<LinePlot[]>;
   async retrieve(keys: Params): Promise<LinePlot | LinePlot[]> {
     const isMany = Array.isArray(keys);
-    const normalized = toArray(keys);
     const res = await sendRequired(
       this.client,
       RETRIEVE_ENDPOINT,
-      { keys: normalized },
+      { keys: toArray(keys) },
       retrieveReqZ,
       retrieveResZ,
     );
@@ -117,13 +101,15 @@ export class Client {
   async delete(key: Key): Promise<void>;
   async delete(keys: Key[]): Promise<void>;
   async delete(keys: Params): Promise<void> {
-    const normalized = toArray(keys);
     await sendRequired(
       this.client,
       DELETE_ENDPOINT,
-      { keys: normalized },
+      { keys: toArray(keys) },
       deleteReqZ,
       emptyResZ,
     );
   }
 }
+
+export const ontologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });

package/src/workspace/lineplot/external.ts

@@ -0,0 +1,11 @@
+// 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.
+
+export * from "@/workspace/lineplot/client";
+export * from "@/workspace/lineplot/payload";

package/src/workspace/lineplot/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 * as linePlot from "@/workspace/lineplot/client";
+export * as linePlot from "@/workspace/lineplot/external";

package/src/workspace/lineplot/linePlot.spec.ts

@@ -7,14 +7,13 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+import { NIL as ZERO_UUID } from "uuid";
 import { describe, expect, test } from "vitest";
 
 import { newClient } from "@/setupspecs";
 
 const client = newClient();
 
-const ZERO_UUID = "00000000-0000-0000-0000-000000000000";
-
 describe("LinePlot", () => {
   describe("create", () => {
     test("create one", async () => {

package/src/workspace/lineplot/payload.ts

@@ -0,0 +1,32 @@
+// 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 { unknownRecordZ } from "@synnaxlabs/x/record";
+import { z } from "zod";
+
+import { parseWithoutKeyConversion } from "@/util/parseWithoutKeyConversion";
+
+export const keyZ = z.string().uuid();
+export type Key = z.infer<typeof keyZ>;
+export type Params = Key | Key[];
+
+export const linePlotZ = z.object({
+  key: keyZ,
+  name: z.string(),
+  data: unknownRecordZ.or(z.string().transform(parseWithoutKeyConversion)),
+});
+export interface LinePlot extends z.infer<typeof linePlotZ> {}
+
+export const newZ = linePlotZ
+  .partial({ key: true })
+  .transform((p) => ({ ...p, data: JSON.stringify(p.data) }));
+export interface New extends z.input<typeof newZ> {}
+
+export const ONTOLOGY_TYPE = "lineplot";
+export type OntologyType = typeof ONTOLOGY_TYPE;

package/src/workspace/log/client.ts

@@ -9,27 +9,20 @@
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { toArray, type UnknownRecord } from "@synnaxlabs/x";
-import { unknownRecordZ } from "@synnaxlabs/x/record";
 import { z } from "zod";
 
 import { ontology } from "@/ontology";
-
-export const keyZ = z.string().uuid();
-export type Key = z.infer<typeof keyZ>;
-export type Params = Key | Key[];
-
-export const logZ = z.object({
-  key: z.string(),
-  name: z.string(),
-  data: unknownRecordZ.or(z.string().transform((s) => JSON.parse(s) as UnknownRecord)),
-});
-
-export type Log = z.infer<typeof logZ>;
-
-export const ONTOLOGY_TYPE: ontology.ResourceType = "log";
-
-export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key });
+import {
+  type Key,
+  keyZ,
+  type Log,
+  logZ,
+  type New,
+  newZ,
+  ONTOLOGY_TYPE,
+  type Params,
+} from "@/workspace/log/payload";
+import { type Key as WorkspaceKey, keyZ as workspaceKeyZ } from "@/workspace/payload";
 
 const RETRIEVE_ENDPOINT = "/workspace/log/retrieve";
 const CREATE_ENDPOINT = "/workspace/log/create";
@@ -37,18 +30,11 @@ const RENAME_ENDPOINT = "/workspace/log/rename";
 const SET_DATA_ENDPOINT = "/workspace/log/set-data";
 const DELETE_ENDPOINT = "/workspace/log/delete";
 
-export const newLogZ = logZ.partial({ key: true }).transform((p) => ({
-  ...p,
-  data: JSON.stringify(p.data),
-}));
-
-export type NewLog = z.input<typeof newLogZ>;
-
-const retrieveReqZ = z.object({ keys: z.string().array() });
-const createReqZ = z.object({ workspace: z.string(), logs: newLogZ.array() });
-const renameReqZ = z.object({ key: z.string(), name: z.string() });
-const setDataReqZ = z.object({ key: z.string(), data: z.string() });
-const deleteReqZ = z.object({ keys: z.string().array() });
+const retrieveReqZ = z.object({ keys: keyZ.array() });
+const createReqZ = z.object({ workspace: workspaceKeyZ, logs: newZ.array() });
+const renameReqZ = z.object({ key: keyZ, name: z.string() });
+const setDataReqZ = z.object({ key: keyZ, data: z.string() });
+const deleteReqZ = z.object({ keys: keyZ.array() });
 
 const retrieveResZ = z.object({ logs: logZ.array() });
 const createResZ = z.object({ logs: logZ.array() });
@@ -61,15 +47,14 @@ export class Client {
     this.client = client;
   }
 
-  async create(workspace: string, log: NewLog): Promise<Log>;
-  async create(workspace: string, logs: NewLog[]): Promise<Log[]>;
-  async create(workspace: string, logs: NewLog | NewLog[]): Promise<Log | Log[]> {
+  async create(workspace: WorkspaceKey, log: New): Promise<Log>;
+  async create(workspace: WorkspaceKey, logs: New[]): Promise<Log[]>;
+  async create(workspace: WorkspaceKey, logs: New | New[]): Promise<Log | Log[]> {
     const isMany = Array.isArray(logs);
-    const normalized = toArray(logs);
     const res = await sendRequired(
       this.client,
       CREATE_ENDPOINT,
-      { workspace, logs: normalized },
+      { workspace, logs: toArray(logs) },
       createReqZ,
       createResZ,
     );
@@ -100,11 +85,10 @@ export class Client {
   async retrieve(keys: Key[]): Promise<Log[]>;
   async retrieve(keys: Params): Promise<Log | Log[]> {
     const isMany = Array.isArray(keys);
-    const normalized = toArray(keys);
     const res = await sendRequired(
       this.client,
       RETRIEVE_ENDPOINT,
-      { keys: normalized },
+      { keys: toArray(keys) },
       retrieveReqZ,
       retrieveResZ,
     );
@@ -114,13 +98,15 @@ export class Client {
   async delete(key: Key): Promise<void>;
   async delete(keys: Key[]): Promise<void>;
   async delete(keys: Params): Promise<void> {
-    const normalized = toArray(keys);
     await sendRequired(
       this.client,
       DELETE_ENDPOINT,
-      { keys: normalized },
+      { keys: toArray(keys) },
       deleteReqZ,
       emptyResZ,
     );
   }
 }
+
+export const ontologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });

package/src/workspace/log/external.ts

@@ -0,0 +1,11 @@
+// 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.
+
+export * from "@/workspace/log/client";
+export * from "@/workspace/log/payload";

package/src/workspace/log/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 * as log from "@/workspace/log/client";
+export * as log from "@/workspace/log/external";

package/src/workspace/log/log.spec.ts

@@ -7,21 +7,17 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+import { NIL as ZERO_UUID } from "uuid";
 import { describe, expect, test } from "vitest";
 
 import { newClient } from "@/setupspecs";
 
 const client = newClient();
 
-const ZERO_UUID = "00000000-0000-0000-0000-000000000000";
-
 describe("Log", () => {
   describe("create", () => {
     test("create one", async () => {
-      const ws = await client.workspaces.create({
-        name: "Log",
-        layout: { one: 1 },
-      });
+      const ws = await client.workspaces.create({ name: "Log", layout: { one: 1 } });
       const log = await client.workspaces.log.create(ws.key, {
         name: "Log",
         data: { one: 1 },
@@ -33,10 +29,7 @@ describe("Log", () => {
   });
   describe("rename", () => {
     test("rename one", async () => {
-      const ws = await client.workspaces.create({
-        name: "Log",
-        layout: { one: 1 },
-      });
+      const ws = await client.workspaces.create({ name: "Log", layout: { one: 1 } });
       const log = await client.workspaces.log.create(ws.key, {
         name: "Log",
         data: { one: 1 },
@@ -48,10 +41,7 @@ describe("Log", () => {
   });
   describe("setData", () => {
     test("set data", async () => {
-      const ws = await client.workspaces.create({
-        name: "Log",
-        layout: { one: 1 },
-      });
+      const ws = await client.workspaces.create({ name: "Log", layout: { one: 1 } });
       const log = await client.workspaces.log.create(ws.key, {
         name: "Log",
         data: { one: 1 },
@@ -63,10 +53,7 @@ describe("Log", () => {
   });
   describe("delete", () => {
     test("delete one", async () => {
-      const ws = await client.workspaces.create({
-        name: "Log",
-        layout: { one: 1 },
-      });
+      const ws = await client.workspaces.create({ name: "Log", layout: { one: 1 } });
       const log = await client.workspaces.log.create(ws.key, {
         name: "Log",
         data: { one: 1 },

package/src/workspace/log/payload.ts

@@ -0,0 +1,32 @@
+// 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 { unknownRecordZ } from "@synnaxlabs/x/record";
+import { z } from "zod";
+
+import { parseWithoutKeyConversion } from "@/util/parseWithoutKeyConversion";
+
+export const keyZ = z.string().uuid();
+export type Key = z.infer<typeof keyZ>;
+export type Params = Key | Key[];
+
+export const logZ = z.object({
+  key: keyZ,
+  name: z.string(),
+  data: unknownRecordZ.or(z.string().transform(parseWithoutKeyConversion)),
+});
+export interface Log extends z.infer<typeof logZ> {}
+
+export const newZ = logZ
+  .partial({ key: true })
+  .transform((p) => ({ ...p, data: JSON.stringify(p.data) }));
+export interface New extends z.input<typeof newZ> {}
+
+export const ONTOLOGY_TYPE = "log";
+export type OntologyType = typeof ONTOLOGY_TYPE;