@synnaxlabs/client 0.38.1 → 0.40.0

package/src/ranger/client.ts

@@ -14,25 +14,23 @@ import { type Series } from "@synnaxlabs/x/telem";
 import { toArray } from "@synnaxlabs/x/toArray";
 import { z } from "zod";
 
-import { type Key as ChannelKey } from "@/channel/payload";
-import { type Retriever as ChannelRetriever } from "@/channel/retriever";
+import { type channel } from "@/channel";
 import { MultipleFoundError, NotFoundError, QueryError } from "@/errors";
 import { type framer } from "@/framer";
 import { type label } from "@/label";
-import { type Label } from "@/label/payload";
-import { type ontology } from "@/ontology";
-import { type Resource } from "@/ontology/payload";
+import { ontology } from "@/ontology";
 import { type Alias, Aliaser } from "@/ranger/alias";
 import { KV } from "@/ranger/kv";
 import {
+  ALIAS_ONTOLOGY_TYPE,
   analyzeParams,
   type Key,
   type Keys,
   keyZ,
   type Name,
   type Names,
-  type NewPayload,
-  ontologyID,
+  type New,
+  ONTOLOGY_TYPE,
   type Params,
   type Payload,
   payloadZ,
@@ -47,7 +45,7 @@ export class Range {
   readonly kv: KV;
   readonly timeRange: TimeRange;
   readonly color: string | undefined;
-  readonly channels: ChannelRetriever;
+  readonly channels: channel.Retriever;
   private readonly aliaser: Aliaser;
   private readonly frameClient: framer.Client;
   private readonly labelClient: label.Client;
@@ -62,7 +60,7 @@ export class Range {
     _frameClient: framer.Client,
     _kv: KV,
     _aliaser: Aliaser,
-    _channels: ChannelRetriever,
+    _channels: channel.Retriever,
     _labelClient: label.Client,
     _ontologyClient: ontology.Client,
     _rangeClient: Client,
@@ -93,22 +91,21 @@ export class Range {
     };
   }
 
-  async setAlias(channel: ChannelKey | Name, alias: string): Promise<void> {
+  async setAlias(channel: channel.Key | Name, alias: string): Promise<void> {
     const ch = await this.channels.retrieve(channel);
     if (ch.length === 0) throw new QueryError(`Channel ${channel} does not exist`);
-
     await this.aliaser.set({ [ch[0].key]: alias });
   }
 
-  async deleteAlias(...channels: ChannelKey[]): Promise<void> {
+  async deleteAlias(...channels: channel.Key[]): Promise<void> {
     await this.aliaser.delete(channels);
   }
 
-  async listAliases(): Promise<Record<ChannelKey, string>> {
+  async listAliases(): Promise<Record<channel.Key, string>> {
     return await this.aliaser.list();
   }
 
-  async resolveAlias(alias: string): Promise<ChannelKey> {
+  async resolveAlias(alias: string): Promise<channel.Key> {
     return await this.aliaser.resolve(alias);
   }
 
@@ -131,14 +128,12 @@ export class Range {
   }
 
   async read(channel: Key | Name): Promise<Series>;
-
   async read(channels: Params): Promise<framer.Frame>;
-
   async read(channels: Params): Promise<Series | framer.Frame> {
     return await this.frameClient.read(this.timeRange, channels);
   }
 
-  async labels(): Promise<Label[]> {
+  async labels(): Promise<label.Label[]> {
     return await this.labelClient.retrieveFor(ontologyID(this.key));
   }
 
@@ -161,7 +156,7 @@ export class Range {
       dependents: initial,
       resourceType: "range",
     });
-    base.onChange((r: Resource[]) =>
+    base.onChange((r: ontology.Resource[]) =>
       wrapper.notify(this.rangeClient.resourcesToRanges(r)),
     );
     wrapper.setCloser(async () => await base.close());
@@ -179,7 +174,7 @@ export class Range {
       dependents: [resourceP],
       relationshipDirection: "to",
     });
-    base.onChange((resources: Resource[]) => {
+    base.onChange((resources: ontology.Resource[]) => {
       const ranges = this.rangeClient.resourcesToRanges(resources);
       if (ranges.length === 0) return;
       const p = ranges[0];
@@ -202,20 +197,18 @@ const retrieveReqZ = z.object({
   offset: z.number().int().optional(),
 });
 
-export type RetrieveRequest = z.infer<typeof retrieveReqZ>;
+export interface RetrieveRequest extends z.infer<typeof retrieveReqZ> {}
 
 const RETRIEVE_ENDPOINT = "/range/retrieve";
 
-const retrieveResZ = z.object({
-  ranges: nullableArrayZ(payloadZ),
-});
+const retrieveResZ = z.object({ ranges: nullableArrayZ(payloadZ) });
 
 export class Client implements AsyncTermSearcher<string, Key, Range> {
   readonly type: string = "range";
   private readonly frameClient: framer.Client;
   private readonly writer: Writer;
   private readonly unaryClient: UnaryClient;
-  private readonly channels: ChannelRetriever;
+  private readonly channels: channel.Retriever;
   private readonly labelClient: label.Client;
   private readonly ontologyClient: ontology.Client;
 
@@ -223,7 +216,7 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
     frameClient: framer.Client,
     writer: Writer,
     unary: UnaryClient,
-    channels: ChannelRetriever,
+    channels: channel.Retriever,
     labelClient: label.Client,
     ontologyClient: ontology.Client,
   ) {
@@ -235,14 +228,9 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
     this.ontologyClient = ontologyClient;
   }
 
-  async create(range: NewPayload, options?: CreateOptions): Promise<Range>;
-
-  async create(ranges: NewPayload[], options?: CreateOptions): Promise<Range[]>;
-
-  async create(
-    ranges: NewPayload | NewPayload[],
-    options?: CreateOptions,
-  ): Promise<Range | Range[]> {
+  async create(range: New, options?: CreateOptions): Promise<Range>;
+  async create(ranges: New[], options?: CreateOptions): Promise<Range[]>;
+  async create(ranges: New | New[], options?: CreateOptions): Promise<Range | Range[]> {
     const single = !Array.isArray(ranges);
     const res = this.sugarMany(await this.writer.create(toArray(ranges), options));
     return single ? res[0] : res;
@@ -265,11 +253,8 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
   }
 
   async retrieve(range: CrudeTimeRange): Promise<Range[]>;
-
   async retrieve(range: Key | Name): Promise<Range>;
-
   async retrieve(range: Keys | Names): Promise<Range[]>;
-
   async retrieve(ranges: Params | CrudeTimeRange): Promise<Range | Range[]> {
     if (typeof ranges === "object" && "start" in ranges)
       return await this.execRetrieve({ overlapsWith: new TimeRange(ranges) });
@@ -343,11 +328,11 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
     );
   }
 
-  resourcesToRanges(resources: Resource[]): Range[] {
+  resourcesToRanges(resources: ontology.Resource[]): Range[] {
     return resources.map((r) => this.resourceToRange(r));
   }
 
-  resourceToRange(resource: Resource): Range {
+  resourceToRange(resource: ontology.Resource): Range {
     return this.sugarOne({
       key: resource.id.key,
       name: resource.data?.name as string,
@@ -356,3 +341,9 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
     });
   }
 }
+
+export const ontologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });
+
+export const aliasOntologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: ALIAS_ONTOLOGY_TYPE, key });

package/src/ranger/external.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.
 
-export type { Alias, AliasChange } from "@/ranger/alias";
+export { type Alias, type AliasChange } from "@/ranger/alias";
 export * from "@/ranger/client";
 export * from "@/ranger/kv";
 export * from "@/ranger/payload";

package/src/ranger/kv.ts

@@ -17,38 +17,19 @@ import { type Key, keyZ } from "@/ranger/payload";
 import { signals } from "@/signals";
 import { nullableArrayZ } from "@/util/zod";
 
-const getReqZ = z.object({
-  range: keyZ,
-  keys: z.string().array(),
-});
+const kvPairZ = z.object({ range: keyZ, key: z.string(), value: z.string() });
+export interface KVPair extends z.infer<typeof kvPairZ> {}
 
-const kvPairZ = z.object({
-  range: keyZ,
-  key: z.string(),
-  value: z.string(),
-});
+const getReqZ = z.object({ range: keyZ, keys: z.string().array() });
+export interface GetRequest extends z.infer<typeof getReqZ> {}
 
-const getResZ = z.object({
-  pairs: nullableArrayZ(kvPairZ),
-});
+const getResZ = z.object({ pairs: nullableArrayZ(kvPairZ) });
 
-export type GetRequest = z.infer<typeof getReqZ>;
+const setReqZ = z.object({ range: keyZ, pairs: kvPairZ.array() });
+export interface SetRequest extends z.infer<typeof setReqZ> {}
 
-const setReqZ = z.object({
-  range: keyZ,
-  pairs: kvPairZ.array(),
-});
-
-export type SetRequest = z.infer<typeof setReqZ>;
-
-const deleteReqZ = z.object({
-  range: keyZ,
-  keys: z.string().array(),
-});
-
-export type DeleteRequest = z.infer<typeof deleteReqZ>;
-
-export type KVPair = z.infer<typeof kvPairZ>;
+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";
@@ -65,9 +46,7 @@ export class KV {
   }
 
   async get(key: string): Promise<string>;
-
   async get(keys: string[]): Promise<Record<string, string>>;
-
   async get(keys: string | string[]): Promise<string | Record<string, string>> {
     const res = await sendRequired(
       this.client,
@@ -85,9 +64,7 @@ export class KV {
   }
 
   async set(key: string, value: string): Promise<void>;
-
   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))

package/src/ranger/payload.ts

@@ -11,48 +11,29 @@ import { TimeRange } from "@synnaxlabs/x/telem";
 import { toArray } from "@synnaxlabs/x/toArray";
 import { z } from "zod";
 
-import { ontology } from "@/ontology";
-
 export const keyZ = z.string().uuid();
 export type Key = z.infer<typeof keyZ>;
-export type Name = string;
+export const nameZ = z.string().min(1);
+export type Name = z.infer<typeof nameZ>;
 export type Keys = Key[];
 export type Names = Name[];
 export type Params = Key | Name | Keys | Names;
 
 export const payloadZ = z.object({
   key: keyZ,
-  name: z.string().min(1),
+  name: nameZ,
   timeRange: TimeRange.z,
   color: z.string().optional(),
 });
-export type Payload = z.infer<typeof payloadZ>;
+export interface Payload extends z.infer<typeof payloadZ> {}
 
-export const newPayloadZ = payloadZ.extend({ key: z.string().uuid().optional() });
-export type NewPayload = z.input<typeof newPayloadZ>;
+export const newZ = payloadZ.partial({ key: true });
+export interface New extends z.input<typeof newZ> {}
 
 export type ParamAnalysisResult =
-  | {
-      single: true;
-      variant: "keys";
-      normalized: Keys;
-      actual: Key;
-      empty: never;
-    }
-  | {
-      single: true;
-      variant: "names";
-      normalized: Names;
-      actual: Name;
-      empty: never;
-    }
-  | {
-      single: false;
-      variant: "keys";
-      normalized: Keys;
-      actual: Keys;
-      empty: boolean;
-    }
+  | { single: true; variant: "keys"; normalized: Keys; actual: Key; empty: never }
+  | { single: true; variant: "names"; normalized: Names; actual: Name; empty: never }
+  | { single: false; variant: "keys"; normalized: Keys; actual: Keys; empty: boolean }
   | {
       single: false;
       variant: "names";
@@ -72,14 +53,11 @@ export const analyzeParams = (ranges: Params): ParamAnalysisResult => {
     normalized: normal,
     actual: ranges,
     empty,
-  } as const as ParamAnalysisResult;
+  } as ParamAnalysisResult;
 };
 
-export const ONTOLOGY_TYPE: ontology.ResourceType = "range";
-export const ALIAS_ONTOLOGY_TYPE: ontology.ResourceType = "range-alias";
-
-export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key });
+export const ONTOLOGY_TYPE = "range";
+export type OntologyType = typeof ONTOLOGY_TYPE;
 
-export const aliasOntologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ALIAS_ONTOLOGY_TYPE, key });
+export const ALIAS_ONTOLOGY_TYPE = "range-alias";
+export type AliasOntologyType = typeof ALIAS_ONTOLOGY_TYPE;

package/src/ranger/ranger.spec.ts

@@ -13,7 +13,6 @@ import { describe, expect, it } from "vitest";
 
 import { QueryError } from "@/errors";
 import { type ranger } from "@/ranger";
-import { type NewPayload } from "@/ranger/payload";
 import { newClient } from "@/setupspecs";
 
 const client = newClient();
@@ -32,7 +31,7 @@ describe("Ranger", () => {
       expect(range.color).toEqual("#E774D0");
     });
     it("should create multiple ranges", async () => {
-      const ranges: NewPayload[] = [
+      const ranges: ranger.New[] = [
         {
           name: "My New One Second Range",
           timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),

package/src/ranger/writer.ts

@@ -11,37 +11,19 @@ import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { z } from "zod";
 
 import { ontology } from "@/ontology";
-import {
-  keyZ,
-  type NewPayload,
-  newPayloadZ,
-  type Payload,
-  payloadZ,
-} from "@/ranger/payload";
+import { keyZ, nameZ, type New, newZ, type Payload, payloadZ } from "@/ranger/payload";
 
-const createResZ = z.object({
-  ranges: payloadZ.array(),
-});
+const createResZ = z.object({ ranges: payloadZ.array() });
 
-const createReqZ = z.object({
-  parent: ontology.idZ.optional(),
-  ranges: newPayloadZ.array(),
-});
+const createReqZ = z.object({ parent: ontology.idZ.optional(), ranges: newZ.array() });
 
-type CreateRequest = z.infer<typeof createReqZ>;
-export type CreateOptions = Pick<CreateRequest, "parent">;
-
-const deleteReqZ = z.object({
-  keys: keyZ.array(),
-});
+interface CreateRequest extends z.infer<typeof createReqZ> {}
+export interface CreateOptions extends Pick<CreateRequest, "parent"> {}
 
+const deleteReqZ = z.object({ keys: keyZ.array() });
 const deleteResZ = z.object({});
 
-const renameReqZ = z.object({
-  key: keyZ,
-  name: z.string(),
-});
-
+const renameReqZ = z.object({ key: keyZ, name: nameZ });
 const renameResZ = z.object({});
 
 const CREATE_ENDPOINT = "/range/create";
@@ -65,7 +47,7 @@ export class Writer {
     );
   }
 
-  async create(ranges: NewPayload[], options?: CreateOptions): Promise<Payload[]> {
+  async create(ranges: New[], options?: CreateOptions): Promise<Payload[]> {
     const res = await sendRequired<typeof createReqZ, typeof createResZ>(
       this.client,
       CREATE_ENDPOINT,

package/src/signals/observable.ts

@@ -14,10 +14,9 @@ import { type Series } from "@synnaxlabs/x/telem";
 import { type channel } from "@/channel";
 import { framer } from "@/framer";
 
-export type Decoder<K, V> = (
-  variant: change.Variant,
-  data: Series,
-) => Array<change.Change<K, V>>;
+export interface Decoder<K, V> {
+  (variant: change.Variant, data: Series): Array<change.Change<K, V>>;
+}
 
 export interface Observable<K, V>
   extends observe.ObservableAsyncCloseable<Array<change.Change<K, V>>> {}

package/src/user/client.ts

@@ -11,7 +11,8 @@ import { type UnaryClient } from "@synnaxlabs/freighter";
 import { toArray } from "@synnaxlabs/x";
 
 import { MultipleFoundError, NotFoundError } from "@/errors";
-import { type Key, type NewUser, type User } from "@/user/payload";
+import { ontology } from "@/ontology";
+import { type Key, type New, ONTOLOGY_TYPE, type User } from "@/user/payload";
 import { Retriever } from "@/user/retriever";
 import { Writer } from "@/user/writer";
 
@@ -24,11 +25,11 @@ export class Client {
     this.reader = new Retriever(client);
   }
 
-  async create(user: NewUser): Promise<User>;
+  async create(user: New): Promise<User>;
 
-  async create(users: NewUser[]): Promise<User[]>;
+  async create(users: New[]): Promise<User[]>;
 
-  async create(users: NewUser | NewUser[]): Promise<User | User[]> {
+  async create(users: New | New[]): Promise<User | User[]> {
     const isMany = Array.isArray(users);
     const res = await this.writer.create(users);
     return isMany ? res : res[0];
@@ -79,3 +80,6 @@ export class Client {
     await this.writer.delete(keys);
   }
 }
+
+export const ontologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });

package/src/user/payload.ts

@@ -9,8 +9,6 @@
 
 import { z } from "zod";
 
-import { ontology } from "@/ontology";
-
 export const keyZ = z.string().uuid();
 export type Key = z.infer<typeof keyZ>;
 
@@ -24,15 +22,13 @@ export const userZ = z.object({
   lastName: z.string().default(""),
   rootUser: z.boolean().default(true),
 });
-export type User = z.infer<typeof userZ>;
+export interface User extends z.infer<typeof userZ> {}
 
-export const newUserZ = userZ
+export const newZ = userZ
   .partial({ key: true, firstName: true, lastName: true })
   .omit({ rootUser: true })
   .extend({ password: z.string().min(1) });
-export type NewUser = z.infer<typeof newUserZ>;
-
-export const ONTOLOGY_TYPE: ontology.ResourceType = "user";
+export interface New extends z.infer<typeof newZ> {}
 
-export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key });
+export const ONTOLOGY_TYPE = "user";
+export type OntologyType = typeof ONTOLOGY_TYPE;

package/src/user/retriever.ts

@@ -17,7 +17,7 @@ const reqZ = z.object({
   keys: keyZ.array().optional(),
   usernames: z.string().array().optional(),
 });
-type Request = z.infer<typeof reqZ>;
+interface Request extends z.infer<typeof reqZ> {}
 const resZ = z.object({ users: nullableArrayZ(userZ) });
 const ENDPOINT = "/user/retrieve";
 

package/src/user/user.spec.ts

@@ -14,31 +14,33 @@ import { AuthError, NotFoundError } from "@/errors";
 import { newClient } from "@/setupspecs";
 import { type user } from "@/user";
 
-type SortType = { username: string };
+interface SortType {
+  username: string;
+}
 
 const sort = (a: SortType, b: SortType) => a.username.localeCompare(b.username);
 
 const client = newClient();
 
-const userOne: user.NewUser = {
-  username: id.id(),
+const userOne: user.New = {
+  username: id.create(),
   password: "test",
   firstName: "George",
   lastName: "Washington",
 };
 
-const userTwo: user.NewUser = { username: id.id(), password: "test" };
+const userTwo: user.New = { username: id.create(), password: "test" };
 
-const userThree: user.NewUser = {
-  username: id.id(),
+const userThree: user.New = {
+  username: id.create(),
   password: "test",
   firstName: "John",
   lastName: "Adams",
 };
 
-const userArray: user.NewUser[] = [
-  { username: id.id(), password: "secondTest", firstName: "Steve" },
-  { username: id.id(), password: "testArray" },
+const userArray: user.New[] = [
+  { username: id.create(), password: "secondTest", firstName: "Steve" },
+  { username: id.create(), password: "testArray" },
 ].sort(sort);
 
 describe("User", () => {
@@ -107,7 +109,7 @@ describe("User", () => {
           expect(res.lastName).toEqual(userOne.lastName);
         });
         test("not found", async () =>
-          await expect(client.user.retrieveByName(id.id())).rejects.toThrow(
+          await expect(client.user.retrieveByName(id.create())).rejects.toThrow(
             NotFoundError,
           ));
       });
@@ -125,13 +127,13 @@ describe("User", () => {
           });
         });
         test("not found", async () => {
-          const res = await client.user.retrieveByName([id.id()]);
+          const res = await client.user.retrieveByName([id.create()]);
           expect(res).toEqual([]);
         });
         test("extra names getting deleted", async () => {
           const res = await client.user.retrieveByName([
             ...userArray.map((u) => u.username),
-            id.id(),
+            id.create(),
           ]);
           expect(res.sort(sort)).toHaveLength(2);
           res.forEach((u, i) => {
@@ -205,7 +207,7 @@ describe("User", () => {
   });
   describe("Change Username", () => {
     test("Successful", async () => {
-      const newUsername = id.id();
+      const newUsername = id.create();
       await expect(
         client.user.changeUsername(userOne.key as string, newUsername),
       ).resolves.toBeUndefined();
@@ -221,12 +223,12 @@ describe("User", () => {
         client.user.changeUsername(userTwo.key as string, userOne.username),
       ).rejects.toThrow(AuthError));
     test("Repeated usernames fail", async () => {
-      const oldUsername = id.id();
+      const oldUsername = id.create();
       const user = await client.user.create({
         username: oldUsername,
         password: "test",
       });
-      const newUsername = id.id();
+      const newUsername = id.create();
       await client.user.changeUsername(user.key, newUsername);
       await expect(
         client.user.create({ username: newUsername, password: "test" }),

package/src/user/writer.ts

@@ -11,16 +11,9 @@ import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { toArray } from "@synnaxlabs/x/toArray";
 import { z } from "zod";
 
-import {
-  type Key,
-  keyZ,
-  type NewUser,
-  newUserZ,
-  type User,
-  userZ,
-} from "@/user/payload";
+import { type Key, keyZ, type New, newZ, type User, userZ } from "@/user/payload";
 
-const createReqZ = z.object({ users: newUserZ.array() });
+const createReqZ = z.object({ users: newZ.array() });
 const createResZ = z.object({ users: userZ.array() });
 
 const changeUsernameReqZ = z.object({ key: keyZ, username: z.string().min(1) });
@@ -48,7 +41,7 @@ export class Writer {
     this.client = client;
   }
 
-  async create(users: NewUser | NewUser[]): Promise<User[]> {
+  async create(users: New | New[]): Promise<User[]> {
     const res = await sendRequired<typeof createReqZ, typeof createResZ>(
       this.client,
       CREATE_ENDPOINT,

package/src/util/decodeJSONString.ts

@@ -0,0 +1,13 @@
+// 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 { binary, type UnknownRecord } from "@synnaxlabs/x";
+
+export const decodeJSONString = (s: string): UnknownRecord =>
+  s ? binary.JSON_CODEC.decodeString(s) : {};

package/src/util/parseWithoutKeyConversion.ts

@@ -0,0 +1,19 @@
+// 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 { type UnknownRecord } from "@synnaxlabs/x/record";
+
+// --- 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 items have keys that are uuids, which have dashes,
+// and those get messed up. So we just use regular JSON for these items.
+export const parseWithoutKeyConversion = (s: string): UnknownRecord =>
+  s ? JSON.parse(s) : {};