@synnaxlabs/client 0.2.0 → 0.13.5

package/{build/main → dist}/setupspecs.d.ts

@@ -1,4 +1,4 @@
-import Synnax, { SynnaxProps } from './lib/client';
+import Synnax, { type SynnaxProps } from './client';
 export declare const HOST = "localhost";
-export declare const PORT = 8080;
+export declare const PORT = 9090;
 export declare const newClient: (...props: SynnaxProps[]) => Synnax;

package/dist/signals/external.d.ts

@@ -0,0 +1 @@
+export * from '../signals/observable';

package/dist/signals/index.d.ts

@@ -0,0 +1 @@
+export * as signals from '../signals/external';

package/dist/signals/observable.d.ts

@@ -0,0 +1,17 @@
+import { observe, type Destructor, type change, type Series } from "@synnaxlabs/x";
+import { type channel } from '../channel';
+import { type framer } from '../framer';
+export type Decoder<K, V> = (variant: change.Variant, data: Series) => Array<change.Change<K, V>>;
+export declare class Observable<K, V> implements observe.Observable<Array<change.Change<K, V>>> {
+    private readonly streamer;
+    private readonly decoder;
+    private readonly base;
+    private readonly closePromise;
+    private readonly deleteChannel?;
+    private readonly setChannel?;
+    private constructor();
+    onChange(handler: observe.Handler<Array<change.Change<K, V>>>): Destructor;
+    close(): Promise<void>;
+    stream(): Promise<void>;
+    static open<K, V>(client: framer.Client, setChannel: channel.Key | channel.Name, deleteChannel: channel.Key | channel.Name, ecd: Decoder<K, V>): Promise<Observable<K, V>>;
+}

package/dist/transport.d.ts

@@ -0,0 +1,10 @@
+import { type Middleware, type StreamClient, type UnaryClient } from "@synnaxlabs/freighter";
+import { type URL } from "@synnaxlabs/x";
+export declare class Transport {
+    readonly url: URL;
+    readonly unary: UnaryClient;
+    readonly stream: StreamClient;
+    readonly secure: boolean;
+    constructor(url: URL, secure?: boolean);
+    use(...middleware: Middleware[]): void;
+}

package/dist/user/index.d.ts

@@ -0,0 +1 @@
+export * as user from '../user/payload';

package/{build/main/lib → dist}/user/payload.d.ts

@@ -1,5 +1,5 @@
-import { z } from 'zod';
-export declare const UserPayloadSchema: z.ZodObject<{
+import { z } from "zod";
+export declare const payloadZ: z.ZodObject<{
     key: z.ZodString;
     username: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -9,4 +9,4 @@ export declare const UserPayloadSchema: z.ZodObject<{
     key: string;
     username: string;
 }>;
-export declare type UserPayload = z.infer<typeof UserPayloadSchema>;
+export type Payload = z.infer<typeof payloadZ>;

package/dist/util/telem.d.ts

@@ -0,0 +1,2 @@
+import { DataType, NativeTypedArray } from "@synnaxlabs/x";
+export declare const randomSeries: (length: number, dataType: DataType) => NativeTypedArray;

package/dist/workspace/client.d.ts

@@ -0,0 +1,22 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type UnknownRecord, type AsyncTermSearcher } from "@synnaxlabs/x";
+import { linePlot } from '../workspace/lineplot';
+import { type Key, type Workspace } from '../workspace/payload';
+import { pid } from '../workspace/pid';
+import { type CrudeWorkspace } from '../workspace/writer';
+export declare class Client implements AsyncTermSearcher<string, Key, Workspace> {
+    readonly pid: pid.Client;
+    readonly linePlot: linePlot.Client;
+    private readonly retriever;
+    private readonly writer;
+    constructor(client: UnaryClient);
+    search(term: string): Promise<Workspace[]>;
+    retrieveByAuthor(author: string): Promise<Workspace[]>;
+    retrieve(key: Key): Promise<Workspace>;
+    retrieve(keys: Key[]): Promise<Workspace[]>;
+    page(offset: number, limit: number): Promise<Workspace[]>;
+    create(workspace: CrudeWorkspace): Promise<Workspace>;
+    rename(key: Key, name: string): Promise<void>;
+    setLayout(key: Key, layout: UnknownRecord): Promise<void>;
+    delete(...keys: Key[]): Promise<void>;
+}

package/dist/workspace/external.d.ts

@@ -0,0 +1,2 @@
+export * from '../workspace/payload';
+export * from '../workspace/client';

package/dist/workspace/index.d.ts

@@ -0,0 +1 @@
+export * as workspace from '../workspace/external';

package/dist/workspace/lineplot/client.d.ts

@@ -0,0 +1,15 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type UnknownRecord } from "@synnaxlabs/x";
+import { type LinePlot, type Key, type Params } from '../../workspace/lineplot/payload';
+import { type CrudeLinePlot } from '../../workspace/lineplot/writer';
+export declare class Client {
+    private readonly writer;
+    private readonly retriever;
+    constructor(client: UnaryClient);
+    create(workspace: string, pid: CrudeLinePlot): Promise<LinePlot>;
+    rename(key: Key, name: string): Promise<void>;
+    setData(key: Key, data: UnknownRecord): Promise<void>;
+    retrieve(key: Key): Promise<LinePlot>;
+    retrieve(keys: Key[]): Promise<LinePlot[]>;
+    delete(keys: Params): Promise<void>;
+}

package/dist/workspace/lineplot/external.d.ts

@@ -0,0 +1,2 @@
+export * from '../../workspace/lineplot/payload';
+export * from '../../workspace/lineplot/client';

package/dist/workspace/lineplot/index.d.ts

@@ -0,0 +1 @@
+export * as linePlot from '../../workspace/lineplot/external';

package/dist/workspace/lineplot/linePlot.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workspace/lineplot/payload.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+export declare const keyZ: z.ZodString;
+export type Key = z.infer<typeof keyZ>;
+export type Params = Key | Key[];
+export declare const linePlotZ: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+    data: z.ZodRecord<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodSymbol]>, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    key: string;
+    data: Record<string | number | symbol, unknown>;
+}, {
+    name: string;
+    key: string;
+    data: Record<string | number | symbol, unknown>;
+}>;
+export declare const linePlotRemoteZ: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+    data: z.ZodEffects<z.ZodString, Partial<Record<import("@synnaxlabs/x").Key, unknown>>, string>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    key: string;
+    data: Partial<Record<import("@synnaxlabs/x").Key, unknown>>;
+}, {
+    name: string;
+    key: string;
+    data: string;
+}>;
+export type LinePlot = z.infer<typeof linePlotZ>;

package/dist/workspace/lineplot/retriever.d.ts

@@ -0,0 +1,9 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type LinePlot, type Params } from '../../workspace/lineplot/payload';
+export declare class Retriever {
+    private readonly ENDPOINT;
+    private readonly client;
+    constructor(client: UnaryClient);
+    retrieve(params: Params): Promise<LinePlot[]>;
+    private execute;
+}

package/dist/workspace/lineplot/writer.d.ts

@@ -0,0 +1,39 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type UnknownRecord } from "@synnaxlabs/x";
+import { z } from "zod";
+import { type LinePlot, type Params, type Key } from '../../workspace/lineplot/payload';
+export declare const crudeLinePlotZ: z.ZodObject<{
+    name: z.ZodString;
+    key: z.ZodOptional<z.ZodString>;
+    data: z.ZodRecord<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodSymbol]>, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    data: Record<string | number | symbol, unknown>;
+    key?: string | undefined;
+}, {
+    name: string;
+    data: Record<string | number | symbol, unknown>;
+    key?: string | undefined;
+}>;
+export declare const linePlotWriteZ: z.ZodObject<{
+    name: z.ZodString;
+    key: z.ZodOptional<z.ZodString>;
+    data: z.ZodEffects<z.ZodString, Partial<Record<import("@synnaxlabs/x").Key, unknown>>, string>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    data: Partial<Record<import("@synnaxlabs/x").Key, unknown>>;
+    key?: string | undefined;
+}, {
+    name: string;
+    data: string;
+    key?: string | undefined;
+}>;
+export type CrudeLinePlot = z.infer<typeof crudeLinePlotZ>;
+export declare class Writer {
+    private readonly client;
+    constructor(client: UnaryClient);
+    create(workspace: string, plot: CrudeLinePlot): Promise<LinePlot>;
+    delete(params: Params): Promise<void>;
+    rename(pid: Key, name: string): Promise<void>;
+    setData(pid: Key, data: UnknownRecord): Promise<void>;
+}

package/dist/workspace/payload.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+export declare const keyZ: z.ZodString;
+export type Key = z.infer<typeof keyZ>;
+export type Params = Key | Key[];
+export declare const workspaceZ: z.ZodObject<{
+    name: z.ZodString;
+    key: z.ZodString;
+    layout: z.ZodRecord<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodSymbol]>, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    key: string;
+    layout: Record<string | number | symbol, unknown>;
+}, {
+    name: string;
+    key: string;
+    layout: Record<string | number | symbol, unknown>;
+}>;
+export declare const workspaceRemoteZ: z.ZodObject<{
+    name: z.ZodString;
+    key: z.ZodString;
+    layout: z.ZodEffects<z.ZodString, Partial<Record<import("@synnaxlabs/x").Key, unknown>>, string>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    key: string;
+    layout: Partial<Record<import("@synnaxlabs/x").Key, unknown>>;
+}, {
+    name: string;
+    key: string;
+    layout: string;
+}>;
+export type Workspace = z.infer<typeof workspaceZ>;

package/dist/workspace/pid/client.d.ts

@@ -0,0 +1,16 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type UnknownRecord } from "@synnaxlabs/x";
+import { type Key, type Params, type PID } from '../../workspace/pid/payload';
+import { type UncreatedPID } from '../../workspace/pid/writer';
+export declare class Client {
+    private readonly writer;
+    private readonly retriever;
+    constructor(client: UnaryClient);
+    create(workspace: string, pid: UncreatedPID): Promise<PID>;
+    rename(key: Key, name: string): Promise<void>;
+    setData(key: Key, data: UnknownRecord): Promise<void>;
+    retrieve(key: Key): Promise<PID>;
+    retrieve(keys: Key[]): Promise<PID[]>;
+    delete(keys: Params): Promise<void>;
+    copy(key: Key, name: string, snapshot: boolean): Promise<PID>;
+}

package/dist/workspace/pid/external.d.ts

@@ -0,0 +1,2 @@
+export * from '../../workspace/pid/payload';
+export * from '../../workspace/pid/client';

package/dist/workspace/pid/index.d.ts

@@ -0,0 +1 @@
+export * as pid from '../../workspace/pid/external';

package/dist/workspace/pid/payload.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+export declare const keyZ: z.ZodString;
+export type Key = z.infer<typeof keyZ>;
+export type Params = Key | Key[];
+export declare const pidZ: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+    data: z.ZodRecord<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodSymbol]>, z.ZodUnknown>;
+    snapshot: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    key: string;
+    data: Record<string | number | symbol, unknown>;
+    snapshot: boolean;
+}, {
+    name: string;
+    key: string;
+    data: Record<string | number | symbol, unknown>;
+    snapshot: boolean;
+}>;
+export declare const pidRemoteZ: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+    snapshot: z.ZodBoolean;
+    data: z.ZodEffects<z.ZodString, Partial<Record<import("@synnaxlabs/x").Key, unknown>>, string>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    key: string;
+    data: Partial<Record<import("@synnaxlabs/x").Key, unknown>>;
+    snapshot: boolean;
+}, {
+    name: string;
+    key: string;
+    data: string;
+    snapshot: boolean;
+}>;
+export type PID = z.infer<typeof pidZ>;

package/dist/workspace/pid/pid.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workspace/pid/retriever.d.ts

@@ -0,0 +1,9 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type PID, type Params } from "./payload";
+export declare class Retriever {
+    private readonly ENDPOINT;
+    private readonly client;
+    constructor(client: UnaryClient);
+    retrieve(params: Params): Promise<PID[]>;
+    private execute;
+}

package/dist/workspace/pid/writer.d.ts

@@ -0,0 +1,46 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type UnknownRecord } from "@synnaxlabs/x";
+import { z } from "zod";
+import { type PID, type Params, type Key } from '../../workspace/pid/payload';
+export declare const crudePIDz: z.ZodObject<{
+    name: z.ZodString;
+    key: z.ZodOptional<z.ZodString>;
+    data: z.ZodRecord<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodSymbol]>, z.ZodUnknown>;
+    snapshot: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    data: Record<string | number | symbol, unknown>;
+    snapshot: boolean;
+    key?: string | undefined;
+}, {
+    name: string;
+    data: Record<string | number | symbol, unknown>;
+    snapshot: boolean;
+    key?: string | undefined;
+}>;
+export declare const pidWriteZ: z.ZodObject<{
+    name: z.ZodString;
+    key: z.ZodOptional<z.ZodString>;
+    data: z.ZodEffects<z.ZodString, Partial<Record<import("@synnaxlabs/x").Key, unknown>>, string>;
+    snapshot: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    data: Partial<Record<import("@synnaxlabs/x").Key, unknown>>;
+    key?: string | undefined;
+    snapshot?: boolean | undefined;
+}, {
+    name: string;
+    data: string;
+    key?: string | undefined;
+    snapshot?: boolean | undefined;
+}>;
+export type UncreatedPID = z.infer<typeof pidWriteZ>;
+export declare class Writer {
+    private readonly client;
+    constructor(client: UnaryClient);
+    create(workspace: string, pid: UncreatedPID): Promise<PID>;
+    copy(key: Key, name: string, snapshot: boolean): Promise<PID>;
+    delete(params: Params): Promise<void>;
+    rename(pid: Key, name: string): Promise<void>;
+    setData(pid: Key, data: UnknownRecord): Promise<void>;
+}

package/dist/workspace/retriever.d.ts

@@ -0,0 +1,12 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type Params, type Workspace } from '../workspace/payload';
+export declare class Retriever {
+    private static readonly ENDPOINT;
+    private readonly client;
+    constructor(client: UnaryClient);
+    retrieve(params: Params): Promise<Workspace[]>;
+    retrieveByAuthor(author: string): Promise<Workspace[]>;
+    search(term: string): Promise<Workspace[]>;
+    page(offset: number, limit: number): Promise<Workspace[]>;
+    private execute;
+}

package/dist/workspace/workspace.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workspace/writer.d.ts

@@ -0,0 +1,55 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type UnknownRecord } from "@synnaxlabs/x";
+import { z } from "zod";
+import { type Workspace } from "./payload";
+declare const crudeWorkspaceZ: z.ZodObject<{
+    name: z.ZodString;
+    key: z.ZodOptional<z.ZodString>;
+    layout: z.ZodRecord<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodSymbol]>, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    layout: Record<string | number | symbol, unknown>;
+    key?: string | undefined;
+}, {
+    name: string;
+    layout: Record<string | number | symbol, unknown>;
+    key?: string | undefined;
+}>;
+export type CrudeWorkspace = z.infer<typeof crudeWorkspaceZ>;
+declare const createResZ: z.ZodObject<{
+    workspaces: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        key: z.ZodString;
+        layout: z.ZodEffects<z.ZodString, Partial<Record<import("@synnaxlabs/x").Key, unknown>>, string>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        key: string;
+        layout: Partial<Record<import("@synnaxlabs/x").Key, unknown>>;
+    }, {
+        name: string;
+        key: string;
+        layout: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    workspaces: {
+        name: string;
+        key: string;
+        layout: Partial<Record<import("@synnaxlabs/x").Key, unknown>>;
+    }[];
+}, {
+    workspaces: {
+        name: string;
+        key: string;
+        layout: string;
+    }[];
+}>;
+export type CreateResponse = z.infer<typeof createResZ>;
+export declare class Writer {
+    private readonly client;
+    constructor(client: UnaryClient);
+    create(workspaces: CrudeWorkspace | CrudeWorkspace[]): Promise<Workspace[]>;
+    delete(keys: string | string[]): Promise<void>;
+    rename(key: string, name: string): Promise<void>;
+    setLayout(key: string, layout: UnknownRecord): Promise<void>;
+}
+export {};

package/package.json

@@ -1,12 +1,10 @@
 {
   "name": "@synnaxlabs/client",
-  "version": "0.2.1",
-  "description": "synnax Client Library",
-  "main": "build/main/index.js",
-  "typings": "build/main/index.d.ts",
-  "module": "build/module/index.js",
-  "repository": "https://github.com/synnaxlabs/synnax",
-  "license": "MIT",
+  "private": false,
+  "version": "0.13.5",
+  "type": "module",
+  "description": "The Client Library for Synnax",
+  "repository": "https://github.com/synnaxlabs/synnax/tree/main/client/ts",
   "keywords": [
     "synnax",
     "grpc",
@@ -17,99 +15,30 @@
     "telemetry",
     "control systems"
   ],
-  "scripts": {
-    "build": "run-p build:*",
-    "build:main": "tsc -p tsconfig.json",
-    "build:module": "tsc -p tsconfig.module.json",
-    "fix": "run-s fix:*",
-    "fix:prettier": "prettier \"src/**/*.ts\" --write",
-    "fix:lint": "eslint src --ext .ts --fix",
-    "test": "run-s build test:*",
-    "test:lint": "eslint src --ext .ts",
-    "test:prettier": "prettier \"src/**/*.ts\" --list-different",
-    "test:unit": "nyc --silent ava",
-    "check-cli": "run-s test diff-integration-tests check-integration-tests",
-    "check-integration-tests": "run-s check-integration-test:*",
-    "diff-integration-tests": "mkdir -p diff && rm -rf diff/test && cp -r test diff/test && rm -rf diff/test/test-*/.git && cd diff && git init --quiet && git add -A && git commit --quiet --no-verify --allow-empty -m 'WIP' && echo '\\n\\nCommitted most recent integration test output in the \"diff\" directory. Review the changes with \"cd diff && git diff HEAD\" or your preferred git diff viewer.'",
-    "watch:build": "tsc -p tsconfig.json -w",
-    "watch:test": "nyc --silent ava --watch",
-    "cov": "run-s build test:unit cov:html cov:lcov",
-    "cov:html": "nyc report --reporter=html",
-    "cov:lcov": "nyc report --reporter=lcov",
-    "cov:send": "run-s cov:lcov && codecov",
-    "cov:check": "nyc report && nyc check-coverage --lines 100 --functions 100 --branches 100",
-    "doc": "run-s doc:html && open-cli build/docs/index.html",
-    "doc:html": "typedoc src/ --exclude **/*.spec.ts --target ES6 --mode file --out build/docs",
-    "doc:json": "typedoc src/ --exclude **/*.spec.ts --target ES6 --mode file --json build/docs/typedoc.json",
-    "doc:publish": "gh-pages -m \"[ci skip] Updates\" -d build/docs",
-    "version": "standard-version",
-    "reset-hard": "git clean -dfx && git reset --hard && yarn",
-    "prepare-release": "run-s reset-hard test cov:check doc:html version doc:publish"
-  },
-  "engines": {
-    "node": ">=10"
-  },
   "dependencies": {
-    "@synnaxlabs/freighter": "^0.2.0",
-    "zod": "^3.19.1"
+    "zod": "3.22.4",
+    "@synnaxlabs/x": "0.7.0",
+    "@synnaxlabs/freighter": "0.4.0"
   },
   "devDependencies": {
-    "@ava/typescript": "^1.1.1",
-    "@istanbuljs/nyc-config-typescript": "^1.0.1",
-    "@typescript-eslint/eslint-plugin": "^4.0.1",
-    "@typescript-eslint/parser": "^4.0.1",
-    "ava": "^3.12.1",
-    "codecov": "^3.5.0",
-    "cspell": "^4.1.0",
-    "cz-conventional-changelog": "^3.3.0",
-    "eslint": "^7.8.0",
-    "eslint-config-prettier": "^6.11.0",
-    "eslint-plugin-eslint-comments": "^3.2.0",
-    "eslint-plugin-functional": "^3.0.2",
-    "eslint-plugin-import": "^2.22.0",
-    "gh-pages": "^3.1.0",
-    "npm-run-all": "^4.1.5",
-    "nyc": "^15.1.0",
-    "open-cli": "^6.0.1",
-    "prettier": "^2.1.1",
-    "standard-version": "^9.0.0",
-    "ts-node": "^9.0.0",
-    "typedoc": "^0.19.0",
-    "typescript": "^4.0.2"
-  },
-  "files": [
-    "build/main",
-    "build/module",
-    "!**/*.spec.*",
-    "!**/*.json",
-    "CHANGELOG.md",
-    "LICENSE",
-    "README.md"
-  ],
-  "ava": {
-    "failFast": true,
-    "timeout": "60s",
-    "typescript": {
-      "rewritePaths": {
-        "src/": "build/main/"
-      }
-    },
-    "files": [
-      "!build/module/**"
-    ]
-  },
-  "config": {
-    "commitizen": {
-      "path": "cz-conventional-changelog"
-    }
+    "@types/node": "^20.8.7",
+    "@vitest/coverage-v8": "^0.34.6",
+    "typescript": "^5.2.2",
+    "vite": "^4.5.0",
+    "vitest": "^0.34.6",
+    "@synnaxlabs/vite-plugin": "0.0.1",
+    "@synnaxlabs/tsconfig": "0.0.1",
+    "eslint-config-synnaxlabs": "0.0.0"
   },
-  "prettier": {
-    "singleQuote": true
-  },
-  "nyc": {
-    "extends": "@istanbuljs/nyc-config-typescript",
-    "exclude": [
-      "**/*.spec.js"
-    ]
+  "main": "dist/client.cjs.js",
+  "module": "dist/client.es.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc --noEmit && vite build",
+    "watch": "tsc --noEmit && vite build --watch",
+    "test": "vitest",
+    "cov": "vitest --coverage",
+    "lint": "eslint \"src/**/*.ts*\"",
+    "fix": "eslint \"src/**/*.ts*\" --fix"
   }
-}
+}

package/src/auth/auth.spec.ts

@@ -0,0 +1,46 @@
+// Copyright 2023 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 { URL } from "@synnaxlabs/x";
+import { describe, expect, test } from "vitest";
+
+import { auth } from "@/auth";
+import { AuthError } from "@/errors";
+import { HOST, PORT } from "@/setupspecs";
+import { Transport } from "@/transport";
+
+describe("auth", () => {
+  test("valid credentials", async () => {
+    const transport = new Transport(new URL({ host: HOST, port: PORT }));
+    const client = new auth.Client(transport.unary, {
+      username: "synnax",
+      password: "seldon",
+    });
+    await client.authenticating;
+    expect(client.authenticated).toBeTruthy();
+  });
+
+  test("invalid credentials", async () => {
+    const transport = new Transport(new URL({ host: HOST, port: PORT }));
+    const client = new auth.Client(transport.unary, {
+      username: "synnax",
+      password: "wrong",
+    });
+    try {
+      await client.authenticating;
+      expect(client.authenticated).toBeFalsy();
+    } catch (e) {
+      expect(client.authenticated).toBeFalsy();
+      expect(e).toBeInstanceOf(AuthError);
+      if (e instanceof AuthError) {
+        expect(e.message).toEqual("Invalid authentication credentials");
+      }
+    }
+  });
+});