@synnaxlabs/client 0.20.0 → 0.22.0

package/src/auth/auth.ts

@@ -10,21 +10,9 @@
 import type { Middleware, UnaryClient } from "@synnaxlabs/freighter";
 import { z } from "zod";
 
-import { AuthError } from "@/errors";
+import { InvalidTokenError } from "@/errors";
 import { user } from "@/user";
 
-export const tokenMiddleware =
-  (token: () => Promise<string>): Middleware =>
-  async (md, next) => {
-    try {
-      const tk = await token();
-      md.params.Authorization = `Bearer ${tk}`;
-    } catch (err) {
-      return [md, err as Error];
-    }
-    return await next(md);
-  };
-
 export const insecureCredentialsZ = z.object({
   username: z.string(),
   password: z.string(),
@@ -40,45 +28,56 @@ export type TokenResponse = z.infer<typeof tokenResponseZ>;
 
 const LOGIN_ENDPOINT = "/auth/login";
 
+const MAX_RETRIES = 3;
+
 export class Client {
-  private token: string | undefined;
+  token: string | undefined;
   private readonly client: UnaryClient;
-  authenticating: Promise<void> | undefined;
+  private readonly credentials: InsecureCredentials;
+  private authenticating: Promise<Error | null> | undefined;
   authenticated: boolean;
   user: user.Payload | undefined;
+  private retryCount: number;
 
   constructor(client: UnaryClient, credentials: InsecureCredentials) {
     this.client = client;
     this.authenticated = false;
-    this.authenticate(credentials);
-  }
-
-  authenticate(credentials: InsecureCredentials): void {
-    this.authenticating = new Promise((resolve, reject) => {
-      this.client
-        .send<typeof insecureCredentialsZ, typeof tokenResponseZ>(
-          LOGIN_ENDPOINT,
-          credentials,
-          insecureCredentialsZ,
-          tokenResponseZ,
-        )
-        .then(([res, err]) => {
-          if (err != null) return reject(err);
-          this.token = res?.token;
-          this.user = res?.user;
-          this.authenticated = true;
-          resolve();
-        })
-        .catch(reject);
-    });
+    this.credentials = credentials;
+    this.retryCount = 0;
   }
 
   middleware(): Middleware {
-    return tokenMiddleware(async () => {
-      if (!this.authenticated) await this.authenticating;
-      if (this.token == null)
-        throw new AuthError("[auth] - attempting to authenticate without a token");
-      return this.token;
-    });
+    const mw: Middleware = async (reqCtx, next) => {
+      if (!this.authenticated && !reqCtx.target.endsWith(LOGIN_ENDPOINT)) {
+        if (this.authenticating == null)
+          this.authenticating = new Promise(async (resolve) => {
+            const [res, err] = await this.client.send(
+              LOGIN_ENDPOINT,
+
+              this.credentials,
+              insecureCredentialsZ,
+              tokenResponseZ,
+            );
+            if (err != null) return resolve(err);
+            this.token = res?.token;
+            this.user = res?.user;
+            this.authenticated = true;
+            resolve(null);
+          });
+        const err = await this.authenticating;
+        if (err != null) return [reqCtx, err];
+      }
+      reqCtx.params.Authorization = `Bearer ${this.token}`;
+      const [resCtx, err] = await next(reqCtx);
+      if (err instanceof InvalidTokenError && this.retryCount < MAX_RETRIES) {
+        this.authenticated = false;
+        this.authenticating = undefined;
+        this.retryCount += 1;
+        return mw(reqCtx, next);
+      }
+      this.retryCount = 0;
+      return [resCtx, err];
+    };
+    return mw;
   }
 }

package/src/channel/batchRetriever.spec.ts

@@ -1,51 +1,51 @@
+import { DataType, Rate } from "@synnaxlabs/x/telem";
 import { describe, expect, it, vi } from "vitest";
-import { newClient } from "@/setupspecs";
-import { DebouncedBatchRetriever, Retriever, analyzeParams } from "@/channel/retriever";
-import { Params, Payload } from "@/channel/payload";
-import { DataType, Rate } from "@synnaxlabs/x";
-
 
+import { type Params, type Payload } from "@/channel/payload";
+import {
+  DebouncedBatchRetriever,
+  type Retriever,
+  type RetrieveOptions,
+  analyzeChannelParams,
+} from "@/channel/retriever";
 
 class MockRetriever implements Retriever {
-  func: (channels: Params, rangeKey?: string) => Promise<Payload[]>;
+  func: (channels: Params, options?: RetrieveOptions) => Promise<Payload[]>;
 
-  constructor(func: (channels: Params, rangeKey?: string) => Promise<Payload[]>) {
+  constructor(
+    func: (channels: Params, options?: RetrieveOptions) => Promise<Payload[]>,
+  ) {
     this.func = func;
   }
 
-  async search(term: string, rangeKey?: string): Promise<Payload[]> {
+  async search(term: string): Promise<Payload[]> {
     throw new Error("Method not implemented.");
   }
 
-  async page(offset: number, limit: number, rangeKey?: string): Promise<Payload[]> {
+  async page(offset: number, limit: number): Promise<Payload[]> {
     throw new Error("Method not implemented.");
   }
 
-  async retrieve(channels: Params, rangeKey?: string): Promise<Payload[]> {
-    return this.func(channels, rangeKey);
+  async retrieve(channels: Params, options?: RetrieveOptions): Promise<Payload[]> {
+    return await this.func(channels, options);
   }
-
 }
 
-
 describe("channelRetriever", () => {
   it("should batch multiple retrieve requests", async () => {
     const called = vi.fn();
     const base = new MockRetriever(async (batch): Promise<Payload[]> => {
       called(batch);
-      const {normalized} = analyzeParams(batch);
-      return normalized.map(
-        (key) =>
-          ({
-            key: key as number,
-            name: `channel-${key}`,
-            dataType: DataType.FLOAT32,
-            isIndex: false,
-            rate: Rate.hz(1),
-            leaseholder: 1,
-            index:0 
-          }),
-      );
+      const { normalized } = analyzeChannelParams(batch);
+      return normalized.map((key) => ({
+        key: key as number,
+        name: `channel-${key}`,
+        dataType: DataType.FLOAT32,
+        isIndex: false,
+        rate: Rate.hz(1),
+        leaseholder: 1,
+        index: 0,
+      }));
     });
     const retriever = new DebouncedBatchRetriever(base, 10);
     const res = await Promise.all([
@@ -61,20 +61,17 @@ describe("channelRetriever", () => {
     const called = vi.fn();
     const base = new MockRetriever(async (batch): Promise<Payload[]> => {
       called(batch);
-      const {normalized} = analyzeParams(batch);
-      return normalized.map(
-        (key) =>
-          ({
-            key: key as number,
-            name: `channel-${key}`,
-            dataType: DataType.FLOAT32,
-            isIndex: false,
-            rate: Rate.hz(1),
-            leaseholder: 1,
-            index:0 
-          }),
-      );
-    })
+      const { normalized } = analyzeChannelParams(batch);
+      return normalized.map((key) => ({
+        key: key as number,
+        name: `channel-${key}`,
+        dataType: DataType.FLOAT32,
+        isIndex: false,
+        rate: Rate.hz(1),
+        leaseholder: 1,
+        index: 0,
+      }));
+    });
     const retriever = new DebouncedBatchRetriever(base, 10);
     const res = await Promise.all([
       retriever.retrieve([1]),

package/src/channel/channel.spec.ts

@@ -7,11 +7,11 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { DataType, Rate, TimeStamp } from "@synnaxlabs/x";
-import { describe, test, expect, it } from "vitest";
+import { DataType, Rate, TimeStamp } from "@synnaxlabs/x/telem";
+import { describe, expect, test, it } from "vitest";
 
 import { Channel } from "@/channel/client";
-import { QueryError } from "@/errors";
+import { NotFoundError, QueryError } from "@/errors";
 import { newClient } from "@/setupspecs";
 
 const client = newClient();
@@ -185,7 +185,7 @@ describe("Channel", () => {
   });
   test("retrieve by key - not found", async () => {
     await expect(async () => await client.channels.retrieve("1-1000")).rejects.toThrow(
-      QueryError,
+      NotFoundError,
     );
   });
   test("retrieve by name", async () => {

package/src/channel/client.ts

@@ -8,17 +8,17 @@
 // included in the file licenses/APL.txt.
 
 import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type AsyncTermSearcher } from "@synnaxlabs/x/search";
 import {
   DataType,
   Rate,
   type TypedArray,
   type CrudeDensity,
   type TimeRange,
-  type AsyncTermSearcher,
-  toArray,
   type CrudeTimeStamp,
   type MultiSeries,
-} from "@synnaxlabs/x";
+} from "@synnaxlabs/x/telem";
+import { toArray } from "@synnaxlabs/x/toArray";
 
 import {
   type Key,
@@ -29,15 +29,18 @@ import {
   type NewPayload,
 } from "@/channel/payload";
 import {
-  analyzeParams,
+  analyzeChannelParams,
   CacheRetriever,
   ClusterRetriever,
   DebouncedBatchRetriever,
   type Retriever,
+  type PageOptions,
+  type RetrieveOptions,
 } from "@/channel/retriever";
 import { type Writer } from "@/channel/writer";
-import { MultipleFoundError, NotFoundError, ValidationError } from "@/errors";
+import { MultipleFoundError, ValidationError } from "@/errors";
 import { type framer } from "@/framer";
+import { checkForMultipleOrNoResults } from "@/util/retrieve";
 
 interface CreateOptions {
   retrieveIfNameExists?: boolean;
@@ -169,6 +172,7 @@ export class Channel {
  * through the `channels` property of an {@link Synnax} client.
  */
 export class Client implements AsyncTermSearcher<string, Key, Channel> {
+  readonly type = "channel";
   private readonly frameClient: framer.Client;
   private readonly client: UnaryClient;
   readonly retriever: Retriever;
@@ -287,7 +291,7 @@ export class Client implements AsyncTermSearcher<string, Key, Channel> {
    * const channel = await client.channels.retrieve(1);
    * ```
    */
-  async retrieve(channel: KeyOrName, rangeKey?: string): Promise<Channel>;
+  async retrieve(channel: KeyOrName, options?: RetrieveOptions): Promise<Channel>;
 
   /**
    * Retrieves multiple channels from the database using the provided keys or the
@@ -301,7 +305,7 @@ export class Client implements AsyncTermSearcher<string, Key, Channel> {
    * @param options.notDataTypes - Limits the query to only channels without the specified
    *
    */
-  async retrieve(channels: Params, rangeKey?: string): Promise<Channel[]>;
+  async retrieve(channels: Params, options?: RetrieveOptions): Promise<Channel[]>;
 
   /**
    * Retrieves a channel from the database using the given parameters.
@@ -310,34 +314,45 @@ export class Client implements AsyncTermSearcher<string, Key, Channel> {
    * @returns The retrieved channel.
    * @raises {QueryError} If the channel does not exist or if multiple results are returned.
    */
-  async retrieve(channels: Params, rangeKey?: string): Promise<Channel | Channel[]> {
-    const { single, actual, normalized } = analyzeParams(channels);
-    if (normalized.length === 0) return [];
-    const res = this.sugar(await this.retriever.retrieve(channels, rangeKey));
-    if (!single) return res;
-    if (res.length === 0)
-      throw new NotFoundError(`channel matching ${actual} not found`);
-    if (res.length > 1)
-      throw new MultipleFoundError(`multiple channels matching ${actual} found`);
-    return res[0];
+  async retrieve(
+    channels: Params,
+    options?: RetrieveOptions,
+  ): Promise<Channel | Channel[]> {
+    const isSingle = !Array.isArray(channels);
+    const res = this.sugar(await this.retriever.retrieve(channels, options));
+    checkForMultipleOrNoResults("channel", channels, res, isSingle);
+    return isSingle ? res[0] : res;
   }
 
-  async delete(channels: Params): Promise<void> {
-    const { normalized, variant } = analyzeParams(channels);
-    if (variant === "keys") return await this.writer.delete({ keys: normalized });
-    return await this.writer.delete({ names: normalized });
+  async search(term: string, options?: RetrieveOptions): Promise<Channel[]> {
+    return this.sugar(await this.retriever.search(term, options));
   }
 
-  async search(term: string, rangeKey?: string): Promise<Channel[]> {
-    return this.sugar(await this.retriever.search(term, rangeKey));
+  async delete(channels: Params): Promise<void> {
+    const { normalized, variant } = analyzeChannelParams(channels);
+    if (variant === "keys")
+      return await this.writer.delete({ keys: normalized as Key[] });
+    return await this.writer.delete({ names: normalized as string[] });
   }
 
-  newSearcherUnderRange(rangeKey?: string): AsyncTermSearcher<string, Key, Channel> {
-    return new SearcherUnderRange(this, rangeKey);
+  newSearcherWithOptions(
+    options: RetrieveOptions,
+  ): AsyncTermSearcher<string, Key, Channel> {
+    return {
+      type: this.type,
+      search: async (term: string) => await this.search(term, options),
+      retrieve: async (keys: Key[]) => await this.retrieve(keys, options),
+      page: async (offset: number, limit: number) =>
+        await this.page(offset, limit, options),
+    };
   }
 
-  async page(offset: number, limit: number, rangeKey?: string): Promise<Channel[]> {
-    return this.sugar(await this.retriever.page(offset, limit, rangeKey));
+  async page(
+    offset: number,
+    limit: number,
+    options?: Omit<RetrieveOptions, "limit" | "offset">,
+  ): Promise<Channel[]> {
+    return this.sugar(await this.retriever.page(offset, limit, options));
   }
 
   createDebouncedBatchRetriever(deb: number = 10): Retriever {
@@ -351,25 +366,3 @@ export class Client implements AsyncTermSearcher<string, Key, Channel> {
     return payloads.map((p) => new Channel({ ...p, frameClient }));
   }
 }
-
-class SearcherUnderRange implements AsyncTermSearcher<string, Key, Channel> {
-  private readonly client: Client;
-  private readonly rangeKey?: string;
-
-  constructor(client: Client, rangeKey?: string) {
-    this.client = client;
-    this.rangeKey = rangeKey;
-  }
-
-  async search(term: string): Promise<Channel[]> {
-    return await this.client.search(term, this.rangeKey);
-  }
-
-  async page(offset: number, limit: number): Promise<Channel[]> {
-    return await this.client.page(offset, limit, this.rangeKey);
-  }
-
-  async retrieve(channels: Key[]): Promise<Channel[]> {
-    return await this.client.retrieve(channels, this.rangeKey);
-  }
-}

package/src/channel/creator.ts

@@ -0,0 +1,37 @@
+// 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 type { UnaryClient } from "@synnaxlabs/freighter";
+import { z } from "zod";
+
+import { type Payload, payload, newPayload, type NewPayload } from "@/channel/payload";
+
+const reqZ = z.object({ channels: newPayload.array() });
+
+const resZ = z.object({ channels: payload.array() });
+
+export class Creator {
+  private static readonly ENDPOINT = "/channel/create";
+  private readonly client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async create(channels: NewPayload[]): Promise<Payload[]> {
+    const [res, err] = await this.client.send<typeof reqZ, typeof resZ>(
+      Creator.ENDPOINT,
+      { channels },
+      reqZ,
+      resZ,
+    );
+    if (err != null) throw err;
+    return res.channels;
+  }
+}

package/src/channel/payload.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 { DataType, Rate } from "@synnaxlabs/x";
+import { DataType, Rate } from "@synnaxlabs/x/telem";
 import { z } from "zod";
 
 export const keyZ = z.number();
@@ -38,6 +38,7 @@ export const newPayload = payload.extend({
   index: z.number().optional(),
   rate: Rate.z.optional().default(0),
   isIndex: z.boolean().optional(),
+  virtual: z.boolean().optional().default(false),
 });
 
 export type NewPayload = z.input<typeof newPayload>;

package/src/channel/retriever.ts

@@ -7,7 +7,8 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 import type { UnaryClient } from "@synnaxlabs/freighter";
-import { debounce, toArray } from "@synnaxlabs/x";
+import { debounce } from "@synnaxlabs/x/debounce";
+import { DataType } from "@synnaxlabs/x/telem";
 import { Mutex } from "async-mutex";
 import { z } from "zod";
 
@@ -16,13 +17,13 @@ import {
   type KeyOrName,
   type Keys,
   type KeysOrNames,
-  type Name,
-  type Names,
   type Params,
   type Payload,
   payload,
 } from "@/channel/payload";
 import { QueryError } from "@/errors";
+import { type ParamAnalysisResult, analyzeParams } from "@/util/retrieve";
+import { nullableArrayZ } from "@/util/zod";
 
 const reqZ = z.object({
   leaseholder: z.number().optional(),
@@ -32,18 +33,34 @@ const reqZ = z.object({
   rangeKey: z.string().optional(),
   limit: z.number().optional(),
   offset: z.number().optional(),
+  dataTypes: DataType.z.array().optional(),
+  notDataTypes: DataType.z.array().optional(),
+  virtual: z.boolean().optional(),
+  isIndex: z.boolean().optional(),
+  internal: z.boolean().optional(),
 });
 
 type Request = z.input<typeof reqZ>;
 
+export type RetrieveOptions = Omit<Request, "keys" | "names" | "search">;
+export type PageOptions = Omit<RetrieveOptions, "offset" | "limit">;
+
 const resZ = z.object({
-  channels: payload.array(),
+  channels: nullableArrayZ(payload),
 });
 
+export const analyzeChannelParams = (
+  channels: Params,
+): ParamAnalysisResult<KeyOrName, { number: "keys"; string: "names" }> =>
+  analyzeParams(channels, {
+    number: "keys",
+    string: "names",
+  });
+
 export interface Retriever {
-  retrieve: (channels: Params, rangeKey?: string) => Promise<Payload[]>;
-  search: (term: string, rangeKey?: string) => Promise<Payload[]>;
-  page: (offset: number, limit: number, rangeKey?: string) => Promise<Payload[]>;
+  retrieve: (channels: Params, opts?: RetrieveOptions) => Promise<Payload[]>;
+  search: (term: string, opts?: RetrieveOptions) => Promise<Payload[]>;
+  page: (offset: number, limit: number, opts?: PageOptions) => Promise<Payload[]>;
 }
 
 export class ClusterRetriever implements Retriever {
@@ -54,17 +71,20 @@ export class ClusterRetriever implements Retriever {
     this.client = client;
   }
 
-  async search(term: string, rangeKey?: string): Promise<Payload[]> {
-    return await this.execute({ search: term, rangeKey });
+  async search(term: string, options?: RetrieveOptions): Promise<Payload[]> {
+    return await this.execute({ search: term, ...options });
   }
 
-  async retrieve(channels: Params, rangeKey?: string): Promise<Payload[]> {
-    const { variant, normalized } = analyzeParams(channels);
-    return await this.execute({ [variant]: normalized, rangeKey });
+  async retrieve(channels: Params, options?: RetrieveOptions): Promise<Payload[]> {
+    let { variant, normalized } = analyzeChannelParams(channels);
+    if (variant === "keys" && (normalized as Key[]).indexOf(0) !== -1)
+      normalized = (normalized as Key[]).filter((k) => k !== 0);
+    if (normalized.length === 0) return [];
+    return await this.execute({ [variant]: normalized, ...options });
   }
 
-  async page(offset: number, limit: number, rangeKey?: string): Promise<Payload[]> {
-    return await this.execute({ offset, limit, rangeKey });
+  async page(offset: number, limit: number, options?: PageOptions): Promise<Payload[]> {
+    return await this.execute({ offset, limit, ...options });
   }
 
   private async execute(request: Request): Promise<Payload[]> {
@@ -90,16 +110,19 @@ export class CacheRetriever implements Retriever {
     this.wrapped = wrapped;
   }
 
-  async search(term: string, rangeKey?: string): Promise<Payload[]> {
-    return await this.wrapped.search(term, rangeKey);
+  async search(term: string, options?: RetrieveOptions): Promise<Payload[]> {
+    return await this.wrapped.search(term, options);
   }
 
-  async page(offset: number, limit: number, rangeKey?: string): Promise<Payload[]> {
-    return await this.wrapped.page(offset, limit, rangeKey);
+  async page(offset: number, limit: number, options?: PageOptions): Promise<Payload[]> {
+    return await this.wrapped.page(offset, limit, options);
   }
 
-  async retrieve(channels: Params): Promise<Payload[]> {
-    const { normalized } = analyzeParams(channels);
+  async retrieve(channels: Params, options?: RetrieveOptions): Promise<Payload[]> {
+    const { normalized } = analyzeParams<string | number>(channels, {
+      string: "names",
+      number: "keys",
+    });
     const results: Payload[] = [];
     const toFetch: KeysOrNames = [];
     normalized.forEach((keyOrName) => {
@@ -108,7 +131,7 @@ export class CacheRetriever implements Retriever {
       else toFetch.push(keyOrName as never);
     });
     if (toFetch.length === 0) return results;
-    const fetched = await this.wrapped.retrieve(toFetch);
+    const fetched = await this.wrapped.retrieve(toFetch, options);
     this.updateCache(fetched);
     return results.concat(fetched);
   }
@@ -127,49 +150,6 @@ export class CacheRetriever implements Retriever {
   }
 }
 
-export type ParamAnalysisResult =
-  | {
-      single: true;
-      variant: "names";
-      normalized: Names;
-      actual: Name;
-    }
-  | {
-      single: true;
-      variant: "keys";
-      normalized: Keys;
-      actual: Key;
-    }
-  | {
-      single: false;
-      variant: "keys";
-      normalized: Keys;
-      actual: Keys;
-    }
-  | {
-      single: false;
-      variant: "names";
-      normalized: Names;
-      actual: Names;
-    };
-
-export const analyzeParams = (channels: Params): ParamAnalysisResult => {
-  let normal = (toArray(channels) as KeysOrNames).filter((c) => c !== 0);
-  let variant: "names" | "keys" = "keys";
-  if (typeof normal[0] === "string") {
-    if (isNaN(parseInt(normal[0]))) variant = "names";
-    else {
-      normal = normal.map((v) => parseInt(v as string));
-    }
-  }
-  return {
-    single: !Array.isArray(channels),
-    variant,
-    normalized: normal,
-    actual: channels,
-  } as const as ParamAnalysisResult;
-};
-
 export interface PromiseFns<T> {
   resolve: (value: T) => void;
   reject: (reason?: any) => void;
@@ -189,22 +169,26 @@ export class DebouncedBatchRetriever implements Retriever {
     }, deb);
   }
 
-  async search(term: string, rangeKey?: string): Promise<Payload[]> {
-    return await this.wrapped.search(term, rangeKey);
+  async search(term: string, options?: RetrieveOptions): Promise<Payload[]> {
+    return await this.wrapped.search(term, options);
   }
 
-  async page(offset: number, limit: number, rangeKey?: string): Promise<Payload[]> {
-    return await this.wrapped.page(offset, limit, rangeKey);
+  async page(
+    offset: number,
+    limit: number,
+    options?: RetrieveOptions,
+  ): Promise<Payload[]> {
+    return await this.wrapped.page(offset, limit, options);
   }
 
   async retrieve(channels: Params): Promise<Payload[]> {
-    const { normalized, variant } = analyzeParams(channels);
+    const { normalized, variant } = analyzeChannelParams(channels);
     // Bypass on name fetches for now.
     if (variant === "names") return await this.wrapped.retrieve(normalized);
     // eslint-disable-next-line @typescript-eslint/promise-function-async
     const a = new Promise<Payload[]>((resolve, reject) => {
       void this.mu.runExclusive(() => {
-        this.requests.set(normalized, { resolve, reject });
+        this.requests.set(normalized as Key[], { resolve, reject });
         this.debouncedRun();
       });
     });
@@ -233,7 +217,7 @@ export const retrieveRequired = async (
   r: Retriever,
   params: Params,
 ): Promise<Payload[]> => {
-  const { normalized } = analyzeParams(params);
+  const { normalized } = analyzeChannelParams(params);
   const results = await r.retrieve(normalized);
   const notFound: KeyOrName[] = [];
   normalized.forEach((v) => {