airfoil 0.4.0 → 0.4.1

package/src/commands/cluster/{topic → table}/create.ts

@@ -1,16 +1,13 @@
-import type { FieldConfig } from "@useairfoil/wings";
-
 import * as p from "@clack/prompts";
-import { WingsClusterMetadata } from "@useairfoil/wings";
+import { Arrow, ClusterClient } from "@useairfoil/wings";
 import { printTable } from "console-table-printer";
 import { Effect, Option } from "effect";
 import { Command, Flag } from "effect/unstable/cli";
 import * as fs from "node:fs";
 
-import { makeClusterMetadataLayer } from "../../../utils/client.js";
-import { hostOption, portOption } from "../../../utils/options.js";
+import { makeClusterClientLayer } from "../../../utils/client";
+import { hostOption, portOption } from "../../../utils/options";
 
-// Supported simple types (no config required)
 const SUPPORTED_INLINE_TYPES = [
   "Int8",
   "Int16",
@@ -40,17 +37,18 @@ const SUPPORTED_INLINE_TYPES = [
 ] as const;
 
 type SupportedInlineType = (typeof SUPPORTED_INLINE_TYPES)[number];
+type FieldConfig = Arrow.FieldConfig;
 
 const parentOption = Flag.string("parent").pipe(
-  Flag.withDescription("Parent namespace in format: tenants/{tenant}/namespaces/{namespace}"),
+  Flag.withDescription("Parent namespace in format: namespaces/{namespace}"),
 );
 
-const topicIdOption = Flag.string("topic-id").pipe(
-  Flag.withDescription("Unique identifier for the topic"),
+const tableIdOption = Flag.string("table-id").pipe(
+  Flag.withDescription("Unique identifier for the table"),
 );
 
 const descriptionOption = Flag.string("description").pipe(
-  Flag.withDescription("Topic description"),
+  Flag.withDescription("Table description"),
   Flag.optional,
 );
 
@@ -64,29 +62,24 @@ const schemaFileOption = Flag.string("schema-file").pipe(
   Flag.optional,
 );
 
-const partitionKeyOption = Flag.string("partition-key").pipe(
-  Flag.withDescription("Name of the field used for partitioning"),
-  Flag.optional,
+const keyFieldOption = Flag.string("key-field").pipe(
+  Flag.withDescription("Name of the field used as the primary key"),
 );
 
-const freshnessSecondsOption = Flag.integer("freshness-seconds").pipe(
-  Flag.withDescription("How often to compact the topic (seconds)"),
-  Flag.withDefault(60),
+const versionFieldOption = Flag.string("version-field").pipe(
+  Flag.withDescription("Name of the field used as the version/timestamp"),
 );
 
-const ttlSecondsOption = Flag.integer("ttl-seconds").pipe(
-  Flag.withDescription("How long to keep topic data (seconds)"),
+const partitionFieldOption = Flag.string("partition-field").pipe(
+  Flag.withDescription("Name of the field used for partitioning"),
   Flag.optional,
 );
 
-const targetFileSizeBytesOption = Flag.integer("target-file-size-bytes").pipe(
-  Flag.withDescription("Target file size for compaction (bytes)"),
-  Flag.withDefault(1024 * 1024),
+const freshnessSecondsOption = Flag.integer("freshness-seconds").pipe(
+  Flag.withDescription("Target freshness interval for compaction (seconds)"),
+  Flag.withDefault(60),
 );
 
-/**
- * Parse a field string in format "name:Type" or "name:Type?" (nullable)
- */
 function parseFieldString(fieldStr: string, index: number): FieldConfig {
   const match = fieldStr.match(/^([^:]+):([^?]+)(\?)?$/);
   if (!match) {
@@ -121,16 +114,10 @@ function parseFieldString(fieldStr: string, index: number): FieldConfig {
   };
 }
 
-/**
- * Parse multiple field strings into FieldConfig array
- */
 function parseFieldsFromArgs(fields: ReadonlyArray<string>): FieldConfig[] {
   return fields.map((field, index) => parseFieldString(field, index));
 }
 
-/**
- * Load fields from a JSON schema file with basic validation
- */
 function loadFieldsFromFile(filePath: string): FieldConfig[] {
   if (!fs.existsSync(filePath)) {
     throw new Error(`Schema file not found: "${filePath}"`);
@@ -162,36 +149,34 @@ function loadFieldsFromFile(filePath: string): FieldConfig[] {
   });
 }
 
-export const createTopicCommand = Command.make(
-  "create-topic",
+export const createTableCommand = Command.make(
+  "create-table",
   {
     parent: parentOption,
-    topicId: topicIdOption,
+    tableId: tableIdOption,
     description: descriptionOption,
     fields: fieldsOption,
     schemaFile: schemaFileOption,
-    partitionKey: partitionKeyOption,
+    keyField: keyFieldOption,
+    versionField: versionFieldOption,
+    partitionField: partitionFieldOption,
     freshnessSeconds: freshnessSecondsOption,
-    ttlSeconds: ttlSecondsOption,
-    targetFileSizeBytes: targetFileSizeBytesOption,
     host: hostOption,
     port: portOption,
   },
   ({
     parent,
-    topicId,
+    tableId,
     description,
     fields,
     schemaFile,
-    partitionKey,
+    keyField,
+    versionField,
+    partitionField,
     freshnessSeconds,
-    ttlSeconds,
-    targetFileSizeBytes,
-    host,
-    port,
   }) =>
     Effect.gen(function* () {
-      p.intro("📋 Create Topic");
+      p.intro("📋 Create Table");
 
       const schemaFilePath = Option.getOrUndefined(schemaFile);
       const hasFields = fields.length > 0;
@@ -206,84 +191,79 @@ export const createTopicCommand = Command.make(
         );
       }
 
-      const topicFields = yield* Effect.try({
+      const tableFields = yield* Effect.try({
         try: () =>
           schemaFilePath ? loadFieldsFromFile(schemaFilePath) : parseFieldsFromArgs(fields),
         catch: (error) => (error instanceof Error ? error : new Error("Failed to parse fields")),
       });
 
-      if (topicFields.length === 0) {
+      if (tableFields.length === 0) {
         return yield* Effect.fail(new Error("At least one field is required"));
       }
 
-      const partitionKeyName = Option.getOrUndefined(partitionKey);
-      let partitionKeyId: bigint | undefined;
-      if (partitionKeyName) {
-        const index = topicFields.findIndex((field) => field.name === partitionKeyName);
-        if (index === -1) {
-          return yield* Effect.fail(
-            new Error(
-              `Partition key field "${partitionKeyName}" not found in fields. Available fields: ${topicFields.map((field) => field.name).join(", ")}`,
-            ),
+      const resolveField = (fieldName: string, role: string): bigint => {
+        const field = tableFields.find((f) => f.name === fieldName);
+        if (!field) {
+          throw new Error(
+            `${role} field "${fieldName}" not found. Available fields: ${tableFields.map((f) => f.name).join(", ")}`,
           );
         }
-        const partitionField = topicFields[index];
-        if (!partitionField) {
-          return yield* Effect.fail(
-            new Error(
-              `Partition key field "${partitionKeyName}" not found in fields. Available fields: ${topicFields.map((field) => field.name).join(", ")}`,
-            ),
-          );
-        }
-        partitionKeyId = partitionField.id;
-      }
+        return field.id;
+      };
+
+      const keyFieldId = yield* Effect.try({
+        try: () => resolveField(keyField, "Key"),
+        catch: (e) => (e instanceof Error ? e : new Error(String(e))),
+      });
 
-      const layer = makeClusterMetadataLayer(host, port);
+      const versionFieldId = yield* Effect.try({
+        try: () => resolveField(versionField, "Version"),
+        catch: (e) => (e instanceof Error ? e : new Error(String(e))),
+      });
+
+      const partitionFieldName = Option.getOrUndefined(partitionField);
+      const partitionFieldId = partitionFieldName
+        ? yield* Effect.try({
+            try: () => resolveField(partitionFieldName, "Partition"),
+            catch: (e) => (e instanceof Error ? e : new Error(String(e))),
+          })
+        : undefined;
 
       const s = p.spinner();
-      s.start("Creating topic...");
+      s.start("Creating table...");
 
-      const topic = yield* WingsClusterMetadata.createTopic({
+      const table = yield* ClusterClient.createTable({
         parent,
-        topicId,
+        tableId,
         description: Option.getOrUndefined(description),
-        fields: topicFields,
-        partitionKey: partitionKeyId,
-        compaction: {
-          freshnessSeconds: BigInt(freshnessSeconds),
-          ttlSeconds: Option.getOrUndefined(Option.map(ttlSeconds, (ttl) => BigInt(ttl))),
-          targetFileSizeBytes: BigInt(targetFileSizeBytes),
-        },
-      }).pipe(
-        Effect.provide(layer),
-        Effect.tapError(() => Effect.sync(() => s.stop("Failed to create topic"))),
-      );
-
-      s.stop("Topic created successfully");
+        fields: tableFields,
+        keyFieldId,
+        versionFieldId,
+        partitionFieldId,
+        targetFreshnessSeconds: BigInt(freshnessSeconds),
+      }).pipe(Effect.tapError(() => Effect.sync(() => s.stop("Failed to create table"))));
+
+      s.stop("Table created successfully");
 
       yield* Effect.sync(() => {
         printTable([
           {
-            name: topic.name,
-            description: topic.description || "-",
-            partition_key:
-              topic.partitionKey !== undefined
-                ? topicFields.find((field) => field.id === topic.partitionKey)?.name ||
-                  topic.partitionKey.toString()
-                : "-",
-            freshness_seconds: topic.compaction.freshnessSeconds.toString(),
-            ttl_seconds: topic.compaction.ttlSeconds?.toString() || "-",
-            target_file_size_bytes: topic.compaction.targetFileSizeBytes.toString(),
-            fields_count: topic.schema.fields.length.toString(),
+            name: table.name,
+            description: table.description || "-",
+            key_field_id: table.keyFieldId.toString(),
+            version_field_id: table.versionFieldId.toString(),
+            partition_field_id: table.partitionFieldId?.toString() || "-",
+            freshness_seconds: table.targetFreshnessSeconds.toString(),
+            fields_count: table.schema.fields.length.toString(),
           },
         ]);
 
-        if (topic.schema.fields.length > 0) {
+        if (table.schema.fields.length > 0) {
           console.log("\nFields:");
           printTable(
-            topic.schema.fields.map((field, index) => ({
-              index: index.toString(),
+            table.schema.fields.map((field) => ({
               name: field.name,
+              id: field.id.toString(),
               type: field.arrowType?._tag ?? "unknown",
               nullable: field.nullable ? "yes" : "no",
             })),
@@ -293,4 +273,7 @@ export const createTopicCommand = Command.make(
         p.outro("✓ Done");
       });
     }),
-).pipe(Command.withDescription("Create a new topic belonging to a namespace"));
+).pipe(
+  Command.withDescription("Create a new table belonging to a namespace"),
+  Command.provide(({ host, port }) => makeClusterClientLayer(host, port)),
+);

package/src/commands/cluster/{tenant → table}/delete.ts

@@ -1,32 +1,32 @@
 import * as p from "@clack/prompts";
-import { WingsClusterMetadata } from "@useairfoil/wings";
+import { ClusterClient } from "@useairfoil/wings";
 import { Effect } from "effect";
 import { Command, Flag } from "effect/unstable/cli";
 
-import { makeClusterMetadataLayer } from "../../../utils/client";
+import { makeClusterClientLayer } from "../../../utils/client";
 import { forceOption, hostOption, portOption } from "../../../utils/options";
 
 const nameOption = Flag.string("name").pipe(
-  Flag.withDescription("Tenant name in format: tenants/{tenant} (e.g., 'tenants/acme-corp')"),
+  Flag.withDescription("Table name in format: namespaces/{namespace}/tables/{table}"),
 );
 
-export const deleteTenantCommand = Command.make(
-  "delete-tenant",
+export const deleteTableCommand = Command.make(
+  "delete-table",
   {
     name: nameOption,
     force: forceOption,
     host: hostOption,
     port: portOption,
   },
-  ({ name, force, host, port }) =>
+  ({ name, force }) =>
     Effect.gen(function* () {
-      p.intro("🗑️  Delete Tenant");
+      p.intro("🗑️  Delete Table");
 
       if (!force) {
         const confirm = yield* Effect.tryPromise({
           try: () =>
             p.confirm({
-              message: `Are you sure you want to delete tenant ${name}?`,
+              message: `Are you sure you want to delete table ${name}?`,
               initialValue: false,
             }),
           catch: () => new Error("Failed to confirm deletion"),
@@ -34,23 +34,21 @@ export const deleteTenantCommand = Command.make(
 
         if (p.isCancel(confirm) || !confirm) {
           p.cancel("Deletion cancelled");
-          process.exit(0);
+          return;
         }
       }
 
-      const layer = makeClusterMetadataLayer(host, port);
-
       const s = p.spinner();
-      s.start("Deleting tenant...");
+      s.start("Deleting table...");
 
-      yield* WingsClusterMetadata.deleteTenant({ name }).pipe(
-        Effect.provide(layer),
-        Effect.tapError(() => Effect.sync(() => s.stop("Failed to delete tenant"))),
+      yield* ClusterClient.deleteTable({ name }).pipe(
+        Effect.tapError(() => Effect.sync(() => s.stop("Failed to delete table"))),
       );
 
-      s.stop("Tenant deleted successfully");
+      s.stop("Table deleted successfully");
       p.outro("✓ Done");
     }),
 ).pipe(
-  Command.withDescription("Delete a tenant from the cluster (fails if tenant has any namespaces)"),
+  Command.withDescription("Delete a table from the cluster"),
+  Command.provide(({ host, port }) => makeClusterClientLayer(host, port)),
 );

package/src/commands/cluster/table/get.ts

@@ -0,0 +1,62 @@
+import * as p from "@clack/prompts";
+import { ClusterClient } from "@useairfoil/wings";
+import { printTable } from "console-table-printer";
+import { Effect } from "effect";
+import { Command, Flag } from "effect/unstable/cli";
+
+import { makeClusterClientLayer } from "../../../utils/client";
+import { hostOption, portOption } from "../../../utils/options";
+
+const nameOption = Flag.string("name").pipe(
+  Flag.withDescription("Table name in format: namespaces/{namespace}/tables/{table}"),
+);
+
+export const getTableCommand = Command.make(
+  "get-table",
+  {
+    name: nameOption,
+    host: hostOption,
+    port: portOption,
+  },
+  ({ name }) =>
+    Effect.gen(function* () {
+      const s = p.spinner();
+      s.start("Fetching table...");
+
+      const table = yield* ClusterClient.getTable({ name }).pipe(
+        Effect.tapError(() => Effect.sync(() => s.stop("Failed to get table"))),
+      );
+
+      s.stop("Table retrieved");
+
+      yield* Effect.sync(() => {
+        printTable([
+          {
+            name: table.name,
+            description: table.description || "-",
+            key_field_id: table.keyFieldId.toString(),
+            version_field_id: table.versionFieldId.toString(),
+            partition_field_id: table.partitionFieldId?.toString() || "-",
+            freshness_seconds: table.targetFreshnessSeconds.toString(),
+          },
+        ]);
+
+        if (table.schema.fields.length > 0) {
+          console.log("\nFields:");
+          printTable(
+            table.schema.fields.map((field) => ({
+              name: field.name,
+              id: field.id.toString(),
+              type: field.arrowType?._tag ?? "unknown",
+              nullable: field.nullable ? "yes" : "no",
+            })),
+          );
+        }
+
+        p.outro("✓ Done");
+      });
+    }),
+).pipe(
+  Command.withDescription("Get details of a specific table"),
+  Command.provide(({ host, port }) => makeClusterClientLayer(host, port)),
+);

package/src/commands/cluster/table/list.ts

@@ -0,0 +1,61 @@
+import * as p from "@clack/prompts";
+import { ClusterClient } from "@useairfoil/wings";
+import { printTable } from "console-table-printer";
+import { Effect, Option } from "effect";
+import { Command, Flag } from "effect/unstable/cli";
+
+import { makeClusterClientLayer } from "../../../utils/client";
+import { hostOption, pageSizeOption, pageTokenOption, portOption } from "../../../utils/options";
+
+const parentOption = Flag.string("parent").pipe(
+  Flag.withDescription("Parent namespace in format: namespaces/{namespace}"),
+);
+
+export const listTablesCommand = Command.make(
+  "list-tables",
+  {
+    parent: parentOption,
+    pageSize: pageSizeOption,
+    pageToken: pageTokenOption,
+    host: hostOption,
+    port: portOption,
+  },
+  ({ parent, pageSize, pageToken }) =>
+    Effect.gen(function* () {
+      const s = p.spinner();
+      s.start("Fetching tables...");
+
+      const response = yield* ClusterClient.listTables({
+        parent,
+        pageSize,
+        pageToken: Option.getOrUndefined(pageToken),
+      }).pipe(Effect.tapError(() => Effect.sync(() => s.stop("Failed to list tables"))));
+
+      s.stop(`Found ${response.tables.length} table(s)`);
+
+      yield* Effect.sync(() => {
+        if (response.tables.length === 0) {
+          p.log.warn("No tables found");
+        } else {
+          printTable(
+            response.tables.map((table) => ({
+              name: table.name,
+              description: table.description || "-",
+              key_field_id: table.keyFieldId.toString(),
+              partition_field_id: table.partitionFieldId?.toString() || "-",
+              freshness_seconds: table.targetFreshnessSeconds.toString(),
+            })),
+          );
+        }
+
+        if (response.nextPageToken) {
+          p.log.info(`Next page token: ${response.nextPageToken}`);
+        }
+
+        p.outro("✓ Done");
+      });
+    }),
+).pipe(
+  Command.withDescription("List all tables belonging to a namespace"),
+  Command.provide(({ host, port }) => makeClusterClientLayer(host, port)),
+);

package/src/commands/dev.ts

@@ -1,8 +1,13 @@
 import { Effect, FileSystem } from "effect";
 import { Command, Flag, Prompt } from "effect/unstable/cli";
-import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
-
-import { checkDockerVersion, createDockerVolume, runDockerContainer } from "../utils/docker";
+import { ChildProcess } from "effect/unstable/process";
+
+import {
+  checkDockerVersion,
+  createDockerVolume,
+  pullDockerImage,
+  runDockerContainer,
+} from "../utils/docker";
 import { downloadWings, getWingsPath } from "../utils/wings";
 
 const dockerOption = Flag.boolean("docker").pipe(
@@ -11,7 +16,7 @@ const dockerOption = Flag.boolean("docker").pipe(
 );
 
 const versionOption = Flag.string("version").pipe(
-  Flag.withDescription("Specify Wings version (e.g., v0.1.0-alpha.11 or 'latest')"),
+  Flag.withDescription("Specify Wings version (e.g., v0.1.0-alpha.14 or 'latest')"),
   Flag.withDefault("latest"),
 );
 
@@ -55,7 +60,6 @@ export const devCommand = Command.make(
 
 const runWithBinary = (options: { version: string; yes: boolean; stress: boolean }) =>
   Effect.gen(function* () {
-    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
     const fs = yield* FileSystem.FileSystem;
 
     yield* Effect.logInfo("🪽 Airfoil Dev");
@@ -90,17 +94,15 @@ const runWithBinary = (options: { version: string; yes: boolean; stress: boolean
 
     yield* Effect.logInfo(`Starting Wings dev server...`);
 
-    const proc = ChildProcess.make(wingsPath, ["dev"], {
+    const handle = yield* ChildProcess.make(wingsPath, ["dev"], {
       stdin: "inherit",
       stdout: "inherit",
     });
 
-    const handle = yield* spawner.spawn(proc);
-
     const exitCode = yield* handle.exitCode;
 
     if (exitCode !== 0) {
-      yield* Effect.fail(new Error(`Process exited with code ${exitCode}`));
+      return yield* Effect.fail(new Error(`Process exited with code ${exitCode}`));
     }
   });
 
@@ -110,11 +112,8 @@ const runWithDocker = (options: { tag: string; forcePull: boolean }) =>
 
     let tag = options.tag;
 
-    // If tag is not "latest" and doesn't include architecture, append it
-    // Format: 0.1.0-alpha.10-aarch64 or 0.1.0-alpha.10-x86_64
     if (tag !== "latest" && !tag.includes("aarch64") && !tag.includes("x86_64")) {
       const arch = process.arch === "arm64" ? "aarch64" : "x86_64";
-      // Remove 'v' prefix if present for docker tags
       const cleanTag = tag.startsWith("v") ? tag.substring(1) : tag;
       tag = `${cleanTag}-${arch}`;
     }
@@ -122,10 +121,15 @@ const runWithDocker = (options: { tag: string; forcePull: boolean }) =>
     const image = `docker.useairfoil.com/airfoil/wings:${tag}`;
 
     yield* Effect.logInfo(`Using Docker image: ${image}`);
-    yield* Effect.logInfo("Ports: 7777 (gRPC), 7780 (http)");
+    yield* Effect.logInfo("Ports: 7777 (gRPC)");
 
     yield* checkDockerVersion();
 
+    if (options.forcePull) {
+      yield* Effect.logInfo(`Pulling Docker image: ${image}`);
+      yield* pullDockerImage(image);
+    }
+
     yield* createDockerVolume("wings-data");
 
     yield* runDockerContainer(image, "wings-data");

package/src/commands/sql.ts

@@ -1,6 +1,6 @@
 import { ArrowFlightSqlClient } from "@useairfoil/flight";
 import { printTable } from "console-table-printer";
-import { Effect, FileSystem, Option } from "effect";
+import { Effect, FileSystem, Option, Stream } from "effect";
 import { Argument, Command, Flag } from "effect/unstable/cli";
 import { Metadata } from "nice-grpc-common";
 
@@ -20,7 +20,7 @@ const fileOption = Flag.string("file").pipe(
 const namespaceOption = Flag.string("namespace").pipe(
   Flag.withAlias("n"),
   Flag.withDescription("Wings namespace"),
-  Flag.withDefault("tenants/default/namespaces/default"),
+  Flag.withDefault("namespaces/default"),
 );
 
 const jsonOption = Flag.boolean("json").pipe(
@@ -58,32 +58,22 @@ export const sqlCommand = Command.make(
 
       yield* Effect.logInfo(`Namespace: ${namespace}`);
 
-      const client = new ArrowFlightSqlClient(
-        {
-          host: hostPort,
-        },
-        {
-          defaultCallOptions: {
-            "*": {
-              metadata: Metadata({
-                "x-wings-namespace": namespace,
-              }),
-            },
+      const client = yield* ArrowFlightSqlClient.make({
+        host: hostPort,
+        defaultCallOptions: {
+          "*": {
+            metadata: Metadata({
+              "x-wings-namespace": namespace,
+            }),
           },
         },
-      );
-
-      const flightInfo = yield* Effect.tryPromise({
-        try: () => client.executeQuery({ query: sqlQuery }),
-        catch: (error) => (error instanceof Error ? error : new Error("Query failed")),
       });
 
-      const batches = yield* Effect.tryPromise({
-        try: () => Array.fromAsync(client.executeFlightInfo(flightInfo)),
-        catch: (error) => (error instanceof Error ? error : new Error("Query failed")),
-      });
+      const flightInfo = yield* client.executeQuery({ query: sqlQuery });
+
+      const batches = yield* client.executeFlightInfo(flightInfo).pipe(Stream.runCollect);
 
-      const data = batches.flatMap((batch) => batch.toArray());
+      const data = Array.from(batches).flatMap(({ batch }) => batch.toArray());
 
       if (json) {
         yield* Effect.log(JSON.stringify(data, null, 2));

package/src/index.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { NodeRuntime, NodeServices } from "@effect/platform-node";
-import { Effect } from "effect";
+import { Effect, Layer } from "effect";
 import { Command } from "effect/unstable/cli";
 import { FetchHttpClient } from "effect/unstable/http";
 
@@ -19,9 +19,9 @@ const cli = Command.run(program, {
   version,
 });
 
-cli.pipe(
-  Effect.provide(FetchHttpClient.layer),
-  Effect.provide(NodeServices.layer),
-  Effect.scoped,
-  NodeRuntime.runMain,
+NodeRuntime.runMain(
+  cli.pipe(
+    Effect.provide(Layer.mergeAll(FetchHttpClient.layer, NodeServices.layer)),
+    Effect.scoped,
+  ),
 );

package/src/utils/client.ts

@@ -1,6 +1,6 @@
-import { WingsClusterMetadata } from "@useairfoil/wings";
+import { ClusterClient } from "@useairfoil/wings";
 
-export const makeClusterMetadataLayer = (host: string, port: number) =>
-  WingsClusterMetadata.layer({
+export const makeClusterClientLayer = (host: string, port: number) =>
+  ClusterClient.layer({
     host: `${host}:${port}`,
   });