airfoil 0.4.4 → 0.4.6

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

@@ -1,279 +0,0 @@
-import * as p from "@clack/prompts";
-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 { makeClusterClientLayer } from "../../../utils/client";
-import { hostOption, portOption } from "../../../utils/options";
-
-const SUPPORTED_INLINE_TYPES = [
-  "Int8",
-  "Int16",
-  "Int32",
-  "Int64",
-  "Uint8",
-  "Uint16",
-  "Uint32",
-  "Uint64",
-  "Bool",
-  "Utf8",
-  "Binary",
-  "Null",
-  "Float16",
-  "Float32",
-  "Float64",
-  "DateDay",
-  "DateMillisecond",
-  "TimestampSecond",
-  "TimestampMillisecond",
-  "TimestampMicrosecond",
-  "TimestampNanosecond",
-  "DurationSecond",
-  "DurationMillisecond",
-  "DurationMicrosecond",
-  "DurationNanosecond",
-] 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: namespaces/{namespace}"),
-);
-
-const tableIdOption = Flag.string("table-id").pipe(
-  Flag.withDescription("Unique identifier for the table"),
-);
-
-const descriptionOption = Flag.string("description").pipe(
-  Flag.withDescription("Table description"),
-  Flag.optional,
-);
-
-const fieldsOption = Flag.string("fields").pipe(
-  Flag.withDescription('Field definitions in format "name:Type" or "name:Type?" for nullable'),
-  Flag.atLeast(0),
-);
-
-const schemaFileOption = Flag.string("schema-file").pipe(
-  Flag.withDescription("Path to JSON file containing FieldConfig[] (for complex types)"),
-  Flag.optional,
-);
-
-const keyFieldOption = Flag.string("key-field").pipe(
-  Flag.withDescription("Name of the field used as the primary key"),
-);
-
-const versionFieldOption = Flag.string("version-field").pipe(
-  Flag.withDescription("Name of the field used as the version/timestamp"),
-);
-
-const partitionFieldOption = Flag.string("partition-field").pipe(
-  Flag.withDescription("Name of the field used for partitioning"),
-  Flag.optional,
-);
-
-const freshnessSecondsOption = Flag.integer("freshness-seconds").pipe(
-  Flag.withDescription("Target freshness interval for compaction (seconds)"),
-  Flag.withDefault(60),
-);
-
-function parseFieldString(fieldStr: string, index: number): FieldConfig {
-  const match = fieldStr.match(/^([^:]+):([^?]+)(\?)?$/);
-  if (!match) {
-    throw new Error(
-      `Invalid field format: "${fieldStr}". Expected format: "name:Type" or "name:Type?"`,
-    );
-  }
-
-  const name = match[1];
-  const dataType = match[2];
-  const nullableMarker = match[3];
-
-  if (!name || !dataType) {
-    throw new Error(
-      `Invalid field format: "${fieldStr}". Expected format: "name:Type" or "name:Type?"`,
-    );
-  }
-
-  const nullable = nullableMarker === "?";
-
-  if (!SUPPORTED_INLINE_TYPES.includes(dataType as SupportedInlineType)) {
-    throw new Error(
-      `Unsupported type: "${dataType}". Supported types: ${SUPPORTED_INLINE_TYPES.join(", ")}. For complex types, use --schema-file.`,
-    );
-  }
-
-  return {
-    name: name.trim(),
-    dataType: dataType as SupportedInlineType,
-    nullable,
-    id: BigInt(index + 1),
-  };
-}
-
-function parseFieldsFromArgs(fields: ReadonlyArray<string>): FieldConfig[] {
-  return fields.map((field, index) => parseFieldString(field, index));
-}
-
-function loadFieldsFromFile(filePath: string): FieldConfig[] {
-  if (!fs.existsSync(filePath)) {
-    throw new Error(`Schema file not found: "${filePath}"`);
-  }
-
-  const content = fs.readFileSync(filePath, "utf-8");
-
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(content);
-  } catch {
-    throw new Error(`Invalid JSON in schema file: "${filePath}"`);
-  }
-
-  if (!Array.isArray(parsed)) {
-    throw new Error(`Schema file must contain an array of fields. Got: ${typeof parsed}`);
-  }
-
-  if (parsed.length === 0) {
-    throw new Error("Schema file contains an empty array. At least one field is required.");
-  }
-
-  return (parsed as FieldConfig[]).map((field, index) => {
-    const fieldId = (field as { id?: bigint | number }).id;
-    return {
-      ...field,
-      id: typeof fieldId === "bigint" ? fieldId : BigInt(fieldId ?? index + 1),
-    };
-  });
-}
-
-export const createTableCommand = Command.make(
-  "create-table",
-  {
-    parent: parentOption,
-    tableId: tableIdOption,
-    description: descriptionOption,
-    fields: fieldsOption,
-    schemaFile: schemaFileOption,
-    keyField: keyFieldOption,
-    versionField: versionFieldOption,
-    partitionField: partitionFieldOption,
-    freshnessSeconds: freshnessSecondsOption,
-    host: hostOption,
-    port: portOption,
-  },
-  ({
-    parent,
-    tableId,
-    description,
-    fields,
-    schemaFile,
-    keyField,
-    versionField,
-    partitionField,
-    freshnessSeconds,
-  }) =>
-    Effect.gen(function* () {
-      p.intro("📋 Create Table");
-
-      const schemaFilePath = Option.getOrUndefined(schemaFile);
-      const hasFields = fields.length > 0;
-
-      if (!hasFields && !schemaFilePath) {
-        return yield* Effect.fail(new Error("Either --fields or --schema-file must be provided"));
-      }
-
-      if (hasFields && schemaFilePath) {
-        return yield* Effect.fail(
-          new Error("Cannot use both --fields and --schema-file. Choose one."),
-        );
-      }
-
-      const tableFields = yield* Effect.try({
-        try: () =>
-          schemaFilePath ? loadFieldsFromFile(schemaFilePath) : parseFieldsFromArgs(fields),
-        catch: (error) => (error instanceof Error ? error : new Error("Failed to parse fields")),
-      });
-
-      if (tableFields.length === 0) {
-        return yield* Effect.fail(new Error("At least one field is required"));
-      }
-
-      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(", ")}`,
-          );
-        }
-        return field.id;
-      };
-
-      const keyFieldId = yield* Effect.try({
-        try: () => resolveField(keyField, "Key"),
-        catch: (e) => (e instanceof Error ? e : new Error(String(e))),
-      });
-
-      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 table...");
-
-      const table = yield* ClusterClient.createTable({
-        parent,
-        tableId,
-        description: Option.getOrUndefined(description),
-        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: 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 (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("Create a new table belonging to a namespace"),
-  Command.provide(({ host, port }) => makeClusterClientLayer(host, port)),
-);

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

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

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

@@ -1,62 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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,136 +0,0 @@
-import { Effect, FileSystem } from "effect";
-import { Command, Flag, Prompt } from "effect/unstable/cli";
-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(
-  Flag.withDescription("Run Wings using Docker (recommended)"),
-  Flag.withDefault(false),
-);
-
-const versionOption = Flag.string("version").pipe(
-  Flag.withDescription("Specify Wings version (e.g., v0.1.0-alpha.14 or 'latest')"),
-  Flag.withDefault("latest"),
-);
-
-const tagOption = Flag.string("tag").pipe(
-  Flag.withDescription("Docker image tag (only with --docker)"),
-  Flag.withDefault("latest"),
-);
-
-const forcePullOption = Flag.boolean("force-pull").pipe(
-  Flag.withDescription("Force pull Docker image even if it exists locally"),
-  Flag.withDefault(false),
-);
-
-const stressOption = Flag.boolean("stress").pipe(
-  Flag.withDescription("Use Wings stress binary variant"),
-  Flag.withDefault(false),
-);
-
-const yesOption = Flag.boolean("yes").pipe(
-  Flag.withAlias("y"),
-  Flag.withDescription("Skip confirmation prompts"),
-  Flag.withDefault(false),
-);
-
-export const devCommand = Command.make(
-  "dev",
-  {
-    docker: dockerOption,
-    version: versionOption,
-    tag: tagOption,
-    forcePull: forcePullOption,
-    stress: stressOption,
-    yes: yesOption,
-  },
-  (options) => (options.docker ? runWithDocker(options) : runWithBinary(options)),
-).pipe(
-  Command.withDescription(
-    "Download and run Wings dev server locally (Docker recommended for portability)",
-  ),
-);
-
-const runWithBinary = (options: { version: string; yes: boolean; stress: boolean }) =>
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-
-    yield* Effect.logInfo("🪽 Airfoil Dev");
-
-    const version = options.version;
-    const isStress = options.stress;
-    const wingsPath = yield* getWingsPath(version, isStress);
-    const exists = yield* fs.exists(wingsPath);
-
-    if (!exists) {
-      yield* Effect.logWarning(
-        `Wings${isStress ? " stress" : ""} binary not found for version ${version}`,
-      );
-
-      if (!options.yes) {
-        const confirm = yield* Prompt.confirm({
-          message: `Download Wings${isStress ? " stress" : ""} ${version} binary? (~100MB)`,
-          initial: true,
-        });
-
-        if (!confirm) {
-          return yield* Effect.fail(new Error("Download cancelled"));
-        }
-      }
-
-      yield* Effect.logInfo(`Downloading Wings${isStress ? " stress" : ""} ${version}...`);
-
-      yield* downloadWings(version, wingsPath, isStress);
-    } else {
-      yield* Effect.logInfo(`Using cached Wings${isStress ? " stress" : ""} binary (${version})`);
-    }
-
-    yield* Effect.logInfo(`Starting Wings dev server...`);
-
-    const handle = yield* ChildProcess.make(wingsPath, ["dev"], {
-      stdin: "inherit",
-      stdout: "inherit",
-    });
-
-    const exitCode = yield* handle.exitCode;
-
-    if (exitCode !== 0) {
-      return yield* Effect.fail(new Error(`Process exited with code ${exitCode}`));
-    }
-  });
-
-const runWithDocker = (options: { tag: string; forcePull: boolean }) =>
-  Effect.gen(function* () {
-    yield* Effect.logInfo("🐳 Airfoil Dev (Docker)");
-
-    let tag = options.tag;
-
-    if (tag !== "latest" && !tag.includes("aarch64") && !tag.includes("x86_64")) {
-      const arch = process.arch === "arm64" ? "aarch64" : "x86_64";
-      const cleanTag = tag.startsWith("v") ? tag.substring(1) : tag;
-      tag = `${cleanTag}-${arch}`;
-    }
-
-    const image = `docker.useairfoil.com/airfoil/wings:${tag}`;
-
-    yield* Effect.logInfo(`Using Docker image: ${image}`);
-    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,90 +0,0 @@
-import { ArrowFlightSqlClient } from "@useairfoil/flight";
-import { printTable } from "console-table-printer";
-import { Effect, FileSystem, Option, Stream } from "effect";
-import { Argument, Command, Flag } from "effect/unstable/cli";
-import { Metadata } from "nice-grpc-common";
-
-import { hostOption, portOption } from "../utils/options";
-
-const queryArg = Argument.string("query").pipe(
-  Argument.withDescription("SQL query to execute"),
-  Argument.optional,
-);
-
-const fileOption = Flag.string("file").pipe(
-  Flag.withAlias("f"),
-  Flag.withDescription("Execute SQL from file"),
-  Flag.optional,
-);
-
-const namespaceOption = Flag.string("namespace").pipe(
-  Flag.withAlias("n"),
-  Flag.withDescription("Wings namespace"),
-  Flag.withDefault("namespaces/default"),
-);
-
-const jsonOption = Flag.boolean("json").pipe(
-  Flag.withDescription("Output results as JSON"),
-  Flag.withDefault(false),
-);
-
-export const sqlCommand = Command.make(
-  "sql",
-  {
-    query: queryArg,
-    host: hostOption,
-    port: portOption,
-    file: fileOption,
-    namespace: namespaceOption,
-    json: jsonOption,
-  },
-  ({ query, host, port, file, namespace, json }) =>
-    Effect.gen(function* () {
-      const fs = yield* FileSystem.FileSystem;
-      let sqlQuery = Option.getOrUndefined(query);
-      const filePath = Option.getOrUndefined(file);
-
-      if (filePath) {
-        sqlQuery = yield* fs.readFileString(filePath);
-      }
-
-      if (!sqlQuery) {
-        return yield* Effect.fail(
-          new Error("No query provided. Use a query argument or --file option."),
-        );
-      }
-
-      const hostPort = `${host}:${port}`;
-
-      yield* Effect.logInfo(`Namespace: ${namespace}`);
-
-      const client = yield* ArrowFlightSqlClient.make({
-        host: hostPort,
-        defaultCallOptions: {
-          "*": {
-            metadata: Metadata({
-              "x-wings-namespace": namespace,
-            }),
-          },
-        },
-      });
-
-      const flightInfo = yield* client.executeQuery({ query: sqlQuery });
-
-      const batches = yield* client.executeFlightInfo(flightInfo).pipe(Stream.runCollect);
-
-      const data = Array.from(batches).flatMap(({ batch }) => batch.toArray());
-
-      if (json) {
-        yield* Effect.log(JSON.stringify(data, null, 2));
-      } else if (data.length === 0) {
-        yield* Effect.logWarning("No results returned");
-      } else {
-        printTable(data, {
-          defaultColumnOptions: {
-            alignment: "left",
-          },
-        });
-      }
-    }),
-).pipe(Command.withDescription("Execute SQL queries using Arrow Flight SQL"));

package/src/utils/client.ts

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