@synnaxlabs/x 0.23.0 → 0.24.1

package/src/binary/encoder.spec.ts

@@ -12,7 +12,7 @@ import { z } from "zod";
 
 import { binary } from "@/binary";
 
-const SampleSchema = z.object({
+const sampleSchema = z.object({
   channelKey: z.string(),
   timeStamp: z.number(),
   value: z.unknown(),
@@ -27,7 +27,7 @@ binary.ENCODERS.forEach((e) => {
         value: new Array([1, 2, 3]),
       };
       const encoded = e.encode(sample);
-      expect(e.decode(encoded, SampleSchema)).toEqual(sample);
+      expect(e.decode(encoded, sampleSchema)).toEqual(sample);
     });
   });
 });
@@ -50,7 +50,125 @@ describe("JSON", () => {
       value: new Array([1, 2, 3]),
     };
     const encoded = JSON.stringify(sample);
-    const decoded = binary.JSON_ECD.decodeString(encoded, SampleSchema);
+    const decoded = binary.JSON_ECD.decodeString(encoded, sampleSchema);
     expect(decoded.channelKey).toEqual("test");
   });
+
+  describe("CSVEncoderDecoder", () => {
+    it("should correctly decode CSV data with valid input", () => {
+      const sample = `
+      channelKey,timeStamp,value
+      test,123,5
+      test2,124,6
+      `;
+      const decoded = binary.CSV_ECD.decodeString(sample);
+      expect(decoded).toEqual({
+        channelKey: ["test", "test2"],
+        timeStamp: [123, 124],
+        value: [5, 6],
+      });
+    });
+
+    it("should handle empty CSV data", () => {
+      const sample = `
+      `;
+      const decoded = binary.CSV_ECD.decodeString(sample);
+      expect(decoded).toEqual({});
+    });
+
+    it("should handle CSV with only headers", () => {
+      const sample = `
+      channelKey,timeStamp,value
+      `;
+      const decoded = binary.CSV_ECD.decodeString(sample);
+      expect(decoded).toEqual({
+        channelKey: [],
+        timeStamp: [],
+        value: [],
+      });
+    });
+
+    it("should handle CSV with missing values", () => {
+      const sample = `
+      channelKey,timeStamp,value
+      test,123,
+      test2,124,6
+      `;
+      const decoded = binary.CSV_ECD.decodeString(sample);
+      expect(decoded).toEqual({
+        channelKey: ["test", "test2"],
+        timeStamp: [123, 124],
+        value: [6],
+      });
+    });
+
+    it("should handle CSV with extra values", () => {
+      const sample = `
+      channelKey,timeStamp,value
+      test,123,5,extra
+      test2,124,6
+      `;
+      const decoded = binary.CSV_ECD.decodeString(sample);
+      expect(decoded).toEqual({
+        channelKey: ["test", "test2"],
+        timeStamp: [123, 124],
+        value: [5, 6],
+      });
+    });
+
+    it("should handle CSV with different types of values", () => {
+      const sample = `
+      key,number,string
+      test,123,"hello"
+      test2,456,"world"
+      `;
+      const decoded = binary.CSV_ECD.decodeString(sample);
+      expect(decoded).toEqual({
+        key: ["test", "test2"],
+        number: [123, 456],
+        string: ["hello", "world"],
+      });
+    });
+
+    it("should handle CSV with spaces around values", () => {
+      const sample = `
+      key, number , string
+      test , 123 , "hello"
+      test2 , 456 , "world"
+      `;
+      const decoded = binary.CSV_ECD.decodeString(sample);
+      expect(decoded).toEqual({
+        key: ["test", "test2"],
+        number: [123, 456],
+        string: ["hello", "world"],
+      });
+    });
+
+    it("should handle CSV with empty rows", () => {
+      const sample = `
+      key,number,string
+      test,123,"hello"
+      ,
+      test2,456,"world"
+      `;
+      const decoded = binary.CSV_ECD.decodeString(sample);
+      expect(decoded).toEqual({
+        key: ["test", "test2"],
+        number: [123, 456],
+        string: ["hello", "world"],
+      });
+    });
+
+    it("should handle CSV with single column", () => {
+      const sample = `
+      key
+      test
+      test2
+      `;
+      const decoded = binary.CSV_ECD.decodeString(sample);
+      expect(decoded).toEqual({
+        key: ["test", "test2"],
+      });
+    });
+  });
 });

package/src/binary/encoder.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 { type z,type ZodSchema } from "zod";
+import { type z, type ZodSchema } from "zod";
 
 import { caseconv } from "@/caseconv";
 import { isObject } from "@/identity";
@@ -79,6 +79,96 @@ export class JSONEncoderDecoder implements EncoderDecoder {
   static registerCustomType(): void {}
 }
 
+/**
+ * CSVEncoderDecoder is a CSV implementation of EncoderDecoder.
+ */
+export class CSVEncoderDecoder implements EncoderDecoder {
+  contentType = "text/csv";
+
+  encode(payload: unknown): ArrayBuffer {
+    const csvString = this.encodeString(payload);
+    return new TextEncoder().encode(csvString).buffer;
+  }
+
+  decode<P extends z.ZodTypeAny>(
+    data: Uint8Array | ArrayBuffer,
+    schema?: P,
+  ): z.output<P> {
+    const csvString = new TextDecoder().decode(data);
+    return this.decodeString(csvString, schema);
+  }
+
+  encodeString(payload: unknown): string {
+    if (!Array.isArray(payload) || payload.length === 0 || !isObject(payload[0])) {
+      throw new Error("Payload must be an array of objects");
+    }
+
+    const keys = Object.keys(payload[0]);
+    const csvRows = [keys.join(",")];
+
+    payload.forEach((item: any) => {
+      const values = keys.map((key) => JSON.stringify(item[key] ?? ""));
+      csvRows.push(values.join(","));
+    });
+
+    return csvRows.join("\n");
+  }
+
+  decodeString<P extends z.ZodTypeAny>(data: string, schema?: P): z.output<P> {
+    const [headerLine, ...lines] = data
+      .trim()
+      .split("\n")
+      .map((line) => line.trim());
+    if (headerLine.length === 0)
+      return schema != null ? schema.parse({}) : ({} as z.output<P>);
+    const headers = headerLine.split(",").map((header) => header.trim());
+    const result: { [key: string]: any[] } = {};
+
+    headers.forEach((header) => {
+      result[header] = [];
+    });
+
+    lines.forEach((line) => {
+      const values = line.split(",").map((value) => value.trim());
+      headers.forEach((header, index) => {
+        const v = this.parseValue(values[index]);
+        if (v == null) return;
+        result[header].push(v);
+      });
+    });
+
+    return schema != null ? schema.parse(result) : (result as z.output<P>);
+  }
+
+  private parseValue(value?: string): any {
+    if (value == null || value.length === 0) return null;
+    const num = Number(value);
+    if (!isNaN(num)) return num;
+    if (value.startsWith('"') && value.endsWith('"')) return value.slice(1, -1);
+    return value;
+  }
+
+  static registerCustomType(): void {}
+}
+
+export class TextEncoderDecoder implements EncoderDecoder {
+  contentType = "text/plain";
+
+  encode(payload: unknown): ArrayBuffer {
+    return new TextEncoder().encode(payload as string).buffer;
+  }
+
+  decode<P extends z.ZodTypeAny>(
+    data: Uint8Array | ArrayBuffer,
+    schema?: P,
+  ): z.output<P> {
+    const text = new TextDecoder().decode(data);
+    return schema != null ? schema.parse(text) : (text as z.output<P>);
+  }
+}
+
 export const JSON_ECD = new JSONEncoderDecoder();
+export const CSV_ECD = new CSVEncoderDecoder();
+export const TEXT_ECD = new TextEncoderDecoder();
 
 export const ENCODERS: EncoderDecoder[] = [JSON_ECD];

package/src/caseconv/caseconv.ts

@@ -7,7 +7,12 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { camelKeys as _camelKeys, snakeKeys as _snakeKeys } from "js-convert-case";
+import {
+  camelKeys as _camelKeys,
+  snakeKeys as _snakeKeys,
+  toCamelCase as _toCamelCase,
+  toSnakeCase as _toSnakeCase,
+} from "js-convert-case";
 
 const options = {
   recursive: true,
@@ -20,3 +25,7 @@ export const toSnake = <T>(entity: T): T => _snakeKeys(entity, options) as T;
 export const toCamel = <T>(entity: T): T => _camelKeys(entity, options) as T;
 
 export const capitalize = (str: string): string => str[0].toUpperCase() + str.slice(1);
+
+export const stringToSnake = (str: string): string => _toSnakeCase(str);
+
+export const stringToCamel = (str: string): string => _toCamelCase(str);

package/src/compare/compare.spec.ts

@@ -0,0 +1,49 @@
+// Copyright 2024 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 { compare } from "@/compare";
+
+describe("compare", () => {
+  describe("numericStrings", () => {
+    interface Spec {
+      name: string;
+      input: string[];
+      expected: string[];
+    }
+    const SPECS: Spec[] = [
+      {
+        name: "pure numbers",
+        input: ["5", "4", "3", "2", "1"],
+        expected: ["1", "2", "3", "4", "5"],
+      },
+      {
+        name: "suffixed numbers with equal prefixes",
+        input: ["a5", "a4", "a3", "a2", "a1"],
+        expected: ["a1", "a2", "a3", "a4", "a5"],
+      },
+      {
+        name: "suffixed numbers with different prefixes",
+        input: ["a1", "b1", "a2", "b2", "a3", "b3"],
+        expected: ["a1", "a2", "a3", "b1", "b2", "b3"],
+      },
+      {
+        name: "mixed separators",
+        input: ["a2", "a.1", "a-3", "a_4"],
+        expected: ["a.1", "a2", "a-3", "a_4"],
+      },
+    ];
+    SPECS.forEach((spec) => {
+      it(spec.name, () => {
+        expect(spec.input.sort(compare.stringsWithNumbers)).toEqual(spec.expected);
+      });
+    });
+  });
+});

package/src/compare/compare.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 { isStringer,type Primitive } from "@/primitive";
+import { isStringer, type Primitive } from "@/primitive";
 import { type spatial } from "@/spatial";
 
 export type CompareF<T> = (a: T, b: T) => number;
@@ -40,8 +40,11 @@ export const newF = <T>(v: T, reverse: boolean = false): CompareF<T> => {
     case "boolean":
       f = (a: T, b: T) => Number(a) - Number(b);
       break;
+    case "undefined":
+      f = () => 0;
+      break;
     default:
-      console.warn("sortFunc: unknown type");
+      console.warn(`sortFunc: unknown type ${t}`);
       return () => -1;
   }
   return reverse ? reverseF(f) : f;
@@ -117,3 +120,30 @@ export const isLessThan = (n: number): boolean => n < EQUAL;
 export const isGreaterThan = (n: number): boolean => n > EQUAL;
 
 export const isGreaterThanEqual = (n: number): boolean => n >= EQUAL;
+
+export const stringsWithNumbers = (a: string, b: string): number => {
+  const alphaNumericRegex = /([a-zA-Z]+)|(\d+)/g;
+
+  // Remove separators and split into parts
+  const aParts = a.replace(/[\s_.\-]+/g, "").match(alphaNumericRegex);
+  const bParts = b.replace(/[\s_.\-]+/g, "").match(alphaNumericRegex);
+
+  if (!aParts || !bParts) return 0;
+
+  for (let i = 0; i < Math.min(aParts.length, bParts.length); i++) {
+    const aPart = aParts[i];
+    const bPart = bParts[i];
+
+    if (isNaN(Number(aPart)) && isNaN(Number(bPart))) {
+      const localeComparison = aPart.localeCompare(bPart);
+      if (localeComparison !== 0) return localeComparison;
+    } else if (!isNaN(Number(aPart)) && !isNaN(Number(bPart))) {
+      const numComparison = Number(aPart) - Number(bPart);
+      if (numComparison !== 0) return numComparison;
+    } else {
+      return isNaN(Number(aPart)) ? -1 : 1;
+    }
+  }
+
+  return aParts.length - bParts.length;
+};

package/src/deep/path.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 { deep } from "@/deep";
 import { UnknownRecord } from "@/record";
@@ -63,7 +63,8 @@ describe("path", () => {
       };
       it("should use the custom getter function", () => {
         expect(
-          deep.get(v, "a.value().c", false, {
+          deep.get(v, "a.value().c", {
+            optional: false,
             getter: (obj, key) => {
               if (key === "value()")
                 return (obj as { value: () => { c: number } }).value();

package/src/deep/path.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 { caseconv } from "@/caseconv";
 import { type Join } from "@/join";
 import { type UnknownRecord } from "@/record";
 
@@ -46,29 +47,28 @@ export type Key<T, D extends number = 5> = [D] extends [never]
       }[keyof T]
     : "";
 
-export interface GetOptions {
-  getter?: (obj: unknown, key: string) => unknown;
+export interface GetOptions<O extends boolean | undefined = boolean | undefined> {
+  optional: O;
+  getter?: (obj: UnknownRecord, key: string) => unknown;
 }
 
-export type Get = (<V = unknown, T = UnknownRecord>(
-  obj: T,
-  path: string,
-  allowNull: true,
-  options?: GetOptions,
-) => V | null) &
-  (<V = unknown, T = UnknownRecord>(
+export interface Get {
+  <V = unknown, T = UnknownRecord>(
     obj: T,
     path: string,
-    allowNull?: boolean,
-    options?: GetOptions,
-  ) => V);
+    options?: GetOptions<false>,
+  ): V;
+  <V = unknown, T = UnknownRecord>(
+    obj: T,
+    path: string,
+    options?: GetOptions<boolean | undefined>,
+  ): V | null;
+}
 
-export type TypedGet<V = unknown, T = UnknownRecord> = ((
-  obj: T,
-  path: string,
-  allowNull: true,
-) => V | null) &
-  ((obj: T, path: string, allowNull?: boolean) => V);
+export interface TypedGet<V = unknown, T = UnknownRecord> {
+  (obj: T, path: string, options?: GetOptions<false>): V;
+  (obj: T, path: string, options?: GetOptions<boolean | undefined>): V | null;
+}
 
 export const transformPath = (
   path: string,
@@ -90,19 +90,25 @@ export const transformPath = (
   return result.join(".");
 };
 
+export const pathToSnake = (path: string): string =>
+  transformPath(path, caseconv.stringToSnake);
+
+export const pathToCamel = (path: string): string =>
+  transformPath(path, caseconv.stringToCamel);
+
 export const get = (<V = unknown, T = UnknownRecord>(
   obj: T,
   path: string,
-  allowNull: boolean = false,
-  { getter = (obj, key) => (obj as UnknownRecord)[key] }: GetOptions = {},
+  opts: GetOptions = { optional: false },
 ): V | null => {
+  const { optional, getter = (obj, key) => (obj as UnknownRecord)[key] } = opts;
   const parts = path.split(".");
   if (parts.length === 1 && parts[0] === "") return obj as unknown as V;
   let result: UnknownRecord = obj as UnknownRecord;
   for (const part of parts) {
     const v = getter(result, part);
     if (v == null) {
-      if (allowNull) return null;
+      if (optional) return null;
       throw new Error(`Path ${path} does not exist. ${part} is null`);
     }
     result = v as UnknownRecord;

package/src/migrate/migrate.spec.ts

@@ -10,80 +10,88 @@
 import { describe, expect, it } from "vitest";
 import { z } from "zod";
 
-import {
-  migratable,
-  type Migration,
-  type Migrations,
-  migrator,
-} from "@/migrate/migrate";
+import { migrate } from "@/migrate";
 
-const entityV0_0_0 = migratable.extend({
+const entityV0 = z.object({
+  version: z.literal("0.0.0"),
   name: z.string(),
 });
 
-type EntityV0_0_0 = z.infer<typeof entityV0_0_0>;
+type EntityV0 = z.infer<typeof entityV0>;
 
-const entityV0_0_1 = migratable.extend({
+const entityV1 = z.object({
+  version: z.literal("1.0.0"),
   title: z.string(),
 });
 
-type EntityV0_0_1 = z.infer<typeof entityV0_0_1>;
+const migrateV1 = migrate.createMigration<EntityV0, EntityV1>({
+  name: "entity",
+  inputSchema: entityV0,
+  outputSchema: entityV1,
+  migrate: (entity) => {
+    const { name, ...rest } = entity;
+    return { ...rest, version: "1.0.0", title: entity.name };
+  },
+});
 
-const entityV0_0_2 = migratable.extend({
+type EntityV1 = z.infer<typeof entityV1>;
+
+const entityV2 = z.object({
+  version: z.literal("2.0.0"),
   title: z.string(),
   description: z.string(),
 });
 
-type EntityV0_0_2 = z.infer<typeof entityV0_0_2>;
+type EntityV2 = z.infer<typeof entityV2>;
 
-const migrations: Migrations = {
-  "0.0.0": ((entity: EntityV0_0_0): EntityV0_0_1 => {
+const migrateV2 = migrate.createMigration<EntityV1, EntityV2>({
+  name: "entity",
+  inputSchema: entityV1,
+  outputSchema: entityV2,
+  migrate: (entity) => ({ ...entity, version: "2.0.0", description: "" }),
+});
 
-    const { name, ...rest } = entity;
-    return {
-      ...rest,
-      version: "0.0.1",
-      title: entity.name,
-    };
-  }) as Migration<EntityV0_0_0, EntityV0_0_1>,
-  "0.0.1": (entity: EntityV0_0_1): EntityV0_0_2 => {
-    return {
-      ...entity,
-      version: "0.0.2",
-      description: "",
-    };
-  },
+const migrations: migrate.Migrations = {
+  "0.0.0": migrateV1,
+  "1.0.0": migrateV2,
 };
 
+describe("compareSemVer", () => {
+  it("should return true when the major version is higher", () => {
+    expect(migrate.compareSemVer("1.0.0", "0.0.0")).toBeGreaterThan(0);
+    expect(migrate.semVerNewer("3.0.0", "0.3.0")).toBeTruthy();
+  });
+});
+
 describe("migrator", () => {
-  it("should migrate an entity from v0.0.0 to v0.0.2", () => {
-    const entity: EntityV0_0_0 = {
-      version: "0.0.0",
-      name: "foo",
-    };
-    const migrated = migrator(migrations)(entity);
-    expect(migrated).toEqual({
-      version: "0.0.2",
-      title: "foo",
-      description: "",
-    });
+  it("should migrate an entity from v0 to v2", () => {
+    const entity: EntityV0 = { version: "0.0.0", name: "foo" };
+    const DEFAULT: EntityV2 = { version: "2.0.0", title: "", description: "" };
+    const migrated = migrate.migrator({
+      name: "entity",
+      migrations,
+      def: DEFAULT,
+    })(entity);
+    expect(migrated).toEqual({ version: "2.0.0", title: "foo", description: "" });
   });
-  it("should not migrate an entity from v0.0.2", () => {
-    const entity: EntityV0_0_2 = {
-      version: "0.0.2",
-      title: "foo",
-      description: "bar",
-    };
-    const migrated = migrator(migrations)(entity);
-    expect(migrated).toEqual(entity);
+  it("should migrate an entity from v1 to v2", () => {
+    const entity: EntityV1 = { version: "1.0.0", title: "foo" };
+    const DEFAULT: EntityV2 = { version: "2.0.0", title: "", description: "" };
+    const migrated = migrate.migrator({
+      name: "entity",
+      migrations,
+      def: DEFAULT,
+    })(entity);
+    expect(migrated).toEqual({ version: "2.0.0", title: "foo", description: "" });
   });
-  it("should not migrate an entity from v0.0.3", () => {
-    const entity = {
-      version: "0.0.3",
-      title: "foo",
-      description: "bar",
-    };
-    const migrated = migrator(migrations)(entity);
+  it("should not migrate an entity from v2 to v2", () => {
+    const entity: EntityV2 = { version: "2.0.0", title: "foo", description: "bar" };
+    const DEFAULT: EntityV2 = { version: "2.0.0", title: "", description: "" };
+    const migrated = migrate.migrator({
+      name: "entity",
+      migrations,
+      def: DEFAULT,
+    })(entity);
     expect(migrated).toEqual(entity);
   });
 });