airfoil 0.4.4 → 0.4.6

package/README.md

@@ -1 +1,25 @@
 # Airfoil CLI
+
+This is the CLI for Wings catalogs, namespaces, and tables.
+
+## Install
+
+```bash
+pnpm add -g airfoil
+```
+
+## Usage
+
+```bash
+airfoil --help
+airfoil catalog get analytics
+airfoil namespace list --catalog analytics
+```
+
+## Configuration
+
+| Value                            | Required                         | Default                 |
+| -------------------------------- | -------------------------------- | ----------------------- |
+| `--uri`                          | no                               | `http://localhost:7777` |
+| `--catalog` or `AIRFOIL_CATALOG` | for namespace and table commands | none                    |
+| `--output`                       | no                               | `default`               |

package/dist/index.mjs

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+import { NodeRuntime, NodeServices } from "@effect/platform-node";
+import { Cause, Config, Console, Effect, Formatter, Layer, Logger, Option, Result, Runtime, Schema } from "effect";
+import { Argument, CliError, Command, Flag, GlobalFlag } from "effect/cli";
+import { FetchHttpClient } from "effect/http";
+import { CatalogManager } from "@useairfoil/wings";
+import { encode } from "@toon-format/toon";
+//#region package.json
+var version$1 = "0.4.5";
+//#endregion
+//#region src/utils/json.ts
+const RestCatalogConfigJson = Schema.fromJsonString(CatalogManager.RestCatalogConfig);
+const DefaultValue = Schema.Union([
+	Schema.Boolean,
+	Schema.Number,
+	Schema.String
+]);
+const IcebergTypeSchema = Schema.suspend(() => Schema.Union([
+	Schema.String,
+	Schema.Struct({
+		type: Schema.Literal("struct"),
+		fields: Schema.mutable(Schema.Array(TableFieldSchema))
+	}),
+	Schema.Struct({
+		type: Schema.Literal("list"),
+		"element-id": Schema.Int,
+		element: IcebergTypeSchema,
+		"element-required": Schema.Boolean
+	}),
+	Schema.Struct({
+		type: Schema.Literal("map"),
+		"key-id": Schema.Int,
+		key: IcebergTypeSchema,
+		"value-id": Schema.Int,
+		value: IcebergTypeSchema,
+		"value-required": Schema.Boolean
+	})
+]));
+const TableFieldSchema = Schema.Struct({
+	id: Schema.Int,
+	name: Schema.NonEmptyString,
+	type: IcebergTypeSchema,
+	required: Schema.Boolean,
+	doc: Schema.optional(Schema.String),
+	"initial-default": Schema.optional(DefaultValue),
+	"write-default": Schema.optional(DefaultValue)
+});
+const TableFieldsJson = Schema.fromJsonString(Schema.mutable(Schema.Array(TableFieldSchema)));
+const parseRestCatalogConfig = Schema.decodeUnknownEffect(RestCatalogConfigJson);
+const parseTableFields = Schema.decodeUnknownEffect(TableFieldsJson);
+//#endregion
+//#region src/utils/options.ts
+const WingsUri = GlobalFlag.Setting("uri")({ flag: Flag.String("uri").pipe(Flag.withDefault("http://localhost:7777"), Flag.withDescription("Server URI")) });
+const Output = GlobalFlag.Setting("output")({ flag: Flag.Literals("output", ["default", "json"]).pipe(Flag.withDefault("default"), Flag.withDescription("Log output format")) });
+const catalogFlag = Flag.String("catalog").pipe(Flag.withDescription("Catalog ID. Alternatively, use the AIRFOIL_CATALOG environment variable"), Flag.withFallbackConfig(Config.NonEmptyString("AIRFOIL_CATALOG")));
+//#endregion
+//#region src/commands/catalog.ts
+const idArgument = Argument.String("id").pipe(Argument.withDescription("Catalog ID"));
+const restFlag = Flag.String("rest").pipe(Flag.withDescription("Iceberg REST catalog configuration as JSON"));
+const createCommand$2 = Command.make("create", {
+	id: idArgument,
+	rest: restFlag
+}, ({ id, rest }) => Effect.gen(function* () {
+	const baseUrl = yield* WingsUri;
+	const manager = yield* CatalogManager.make({ baseUrl });
+	const config = yield* parseRestCatalogConfig(rest);
+	const catalog = yield* manager.createCatalog({
+		id,
+		rest: config
+	});
+	yield* Effect.log(catalog);
+})).pipe(Command.withDescription("Create a new catalog"));
+const getCommand$2 = Command.make("get", { id: idArgument }, ({ id }) => Effect.gen(function* () {
+	const baseUrl = yield* WingsUri;
+	const catalog = yield* (yield* CatalogManager.make({ baseUrl })).getCatalog(id);
+	yield* Effect.log(catalog);
+})).pipe(Command.withDescription("Get a catalog"));
+const deleteCommand$2 = Command.make("delete", { id: idArgument }, ({ id }) => Effect.gen(function* () {
+	const baseUrl = yield* WingsUri;
+	yield* (yield* CatalogManager.make({ baseUrl })).deleteCatalog(id);
+	yield* Effect.log({ id });
+})).pipe(Command.withDescription("Delete a catalog"));
+const catalogCommand = Command.make("catalog").pipe(Command.withDescription("Manage catalogs"), Command.withSubcommands([
+	createCommand$2,
+	getCommand$2,
+	deleteCommand$2
+]));
+//#endregion
+//#region src/utils/iceberg.ts
+const NamespaceSegments = Schema.NonEmptyArray(Schema.NonEmptyString);
+const TableSegments = Schema.Array(Schema.NonEmptyString).check(Schema.isMinLength(2));
+const parseNamespaceIdentifier = (name) => Schema.decodeUnknownEffect(NamespaceSegments)(name.split(".")).pipe(Effect.map((namespace) => ({ namespace: Array.from(namespace) })));
+const parseTableIdentifier = (qualifiedName) => Schema.decodeUnknownEffect(TableSegments)(qualifiedName.split(".")).pipe(Effect.map((segments) => ({
+	namespace: segments.slice(0, -1),
+	name: segments[segments.length - 1]
+})));
+const getIcebergCatalog = Effect.fn("getIcebergCatalog")(function* (catalogId) {
+	const baseUrl = yield* WingsUri;
+	return yield* (yield* CatalogManager.make({ baseUrl })).getIcebergCatalog(catalogId);
+});
+const listAllNamespaces = Effect.fn("listAllNamespaces")(function* (iceberg) {
+	let page = yield* iceberg.listNamespaces();
+	const namespaces = [...page.namespaces];
+	while (page.nextPageToken !== void 0) {
+		page = yield* iceberg.listNamespaces({ pageToken: page.nextPageToken });
+		namespaces.push(...page.namespaces);
+	}
+	return namespaces;
+});
+const listAllTables = Effect.fn("listAllTables")(function* (iceberg, namespace) {
+	let page = yield* iceberg.listTables(namespace);
+	const identifiers = [...page.identifiers];
+	while (page.nextPageToken !== void 0) {
+		page = yield* iceberg.listTables(namespace, { pageToken: page.nextPageToken });
+		identifiers.push(...page.identifiers);
+	}
+	return identifiers;
+});
+//#endregion
+//#region src/commands/namespace.ts
+const namespaceArgument$1 = Argument.String("namespace").pipe(Argument.withDescription("Namespace name. Use dot-separated notation for nested namespaces"));
+const parentFlag = Flag.String("parent").pipe(Flag.withDescription("Parent namespace. Use dot-separated notation for nested namespaces"), Flag.optional);
+const createCommand$1 = Command.make("create", {
+	namespace: namespaceArgument$1,
+	catalog: catalogFlag
+}, ({ namespace, catalog }) => Effect.gen(function* () {
+	const id = yield* parseNamespaceIdentifier(namespace);
+	const created = yield* (yield* getIcebergCatalog(catalog)).createNamespace(id);
+	yield* Effect.log(created);
+})).pipe(Command.withDescription("Create a new namespace"));
+const getCommand$1 = Command.make("get", {
+	namespace: namespaceArgument$1,
+	catalog: catalogFlag
+}, ({ namespace, catalog }) => Effect.gen(function* () {
+	const id = yield* parseNamespaceIdentifier(namespace);
+	const metadata = yield* (yield* getIcebergCatalog(catalog)).loadNamespaceMetadata(id);
+	yield* Effect.log({
+		...id,
+		...metadata
+	});
+})).pipe(Command.withDescription("Get a namespace"));
+const deleteCommand$1 = Command.make("delete", {
+	namespace: namespaceArgument$1,
+	catalog: catalogFlag
+}, ({ namespace, catalog }) => Effect.gen(function* () {
+	const id = yield* parseNamespaceIdentifier(namespace);
+	yield* (yield* getIcebergCatalog(catalog)).dropNamespace(id);
+	yield* Effect.log(id);
+})).pipe(Command.withDescription("Delete a namespace"));
+const listCommand$1 = Command.make("list", {
+	parent: parentFlag,
+	catalog: catalogFlag
+}, ({ parent, catalog }) => Effect.gen(function* () {
+	const iceberg = yield* getIcebergCatalog(catalog);
+	const parentName = Option.getOrUndefined(parent);
+	const parentId = parentName === void 0 ? void 0 : yield* parseNamespaceIdentifier(parentName);
+	const result = yield* iceberg.listNamespaces(parentId === void 0 ? void 0 : { parent: parentId });
+	yield* Effect.log(result);
+})).pipe(Command.withDescription("List namespaces"));
+const namespaceCommand = Command.make("namespace").pipe(Command.withDescription("Manage namespaces"), Command.withSubcommands([
+	createCommand$1,
+	getCommand$1,
+	deleteCommand$1,
+	listCommand$1
+]));
+//#endregion
+//#region src/commands/table.ts
+const tableArgument = Argument.String("table").pipe(Argument.withDescription("Fully qualified table name"));
+const namespaceArgument = Argument.String("namespace").pipe(Argument.withDescription("Namespace name. Use dot-separated notation for nested namespaces"), Argument.optional);
+const allFlag = Flag.Boolean("all").pipe(Flag.withDescription("List tables from all namespaces"), Flag.withDefault(false));
+const schemaFlag = Flag.String("schema").pipe(Flag.withDescription("Iceberg table fields as a JSON array"));
+const createCommand = Command.make("create", {
+	table: tableArgument,
+	schema: schemaFlag,
+	catalog: catalogFlag
+}, ({ table, schema, catalog }) => Effect.gen(function* () {
+	const id = yield* parseTableIdentifier(table);
+	const fields = yield* parseTableFields(schema);
+	const metadata = yield* (yield* getIcebergCatalog(catalog)).createTable({ namespace: id.namespace }, {
+		name: id.name,
+		schema: {
+			type: "struct",
+			fields
+		}
+	});
+	yield* Effect.log({
+		...id,
+		metadata
+	});
+})).pipe(Command.withDescription("Create a new table"));
+const getCommand = Command.make("get", {
+	table: tableArgument,
+	catalog: catalogFlag
+}, ({ table, catalog }) => Effect.gen(function* () {
+	const id = yield* parseTableIdentifier(table);
+	const metadata = yield* (yield* getIcebergCatalog(catalog)).loadTable(id);
+	yield* Effect.log({
+		...id,
+		metadata
+	});
+})).pipe(Command.withDescription("Get a table"));
+const deleteCommand = Command.make("delete", {
+	table: tableArgument,
+	catalog: catalogFlag
+}, ({ table, catalog }) => Effect.gen(function* () {
+	const id = yield* parseTableIdentifier(table);
+	yield* (yield* getIcebergCatalog(catalog)).dropTable(id);
+	yield* Effect.log(id);
+})).pipe(Command.withDescription("Delete a table"));
+const listCommand = Command.make("list", {
+	namespace: namespaceArgument,
+	all: allFlag,
+	catalog: catalogFlag
+}, ({ namespace, all, catalog }) => Effect.gen(function* () {
+	const namespaceName = Option.getOrUndefined(namespace);
+	if (namespaceName === void 0 && !all) return yield* new CliError.UserError({
+		cause: "Missing table list selector",
+		userMessage: "Provide a namespace or use --all"
+	});
+	if (namespaceName !== void 0 && all) return yield* new CliError.UserError({
+		cause: "Conflicting table list selectors",
+		userMessage: "Provide either a namespace or --all, not both"
+	});
+	const iceberg = yield* getIcebergCatalog(catalog);
+	const tables = namespaceName === void 0 ? (yield* Effect.forEach(yield* listAllNamespaces(iceberg), (namespace) => listAllTables(iceberg, namespace))).flat() : yield* listAllTables(iceberg, yield* parseNamespaceIdentifier(namespaceName));
+	yield* Effect.log({
+		namespace: namespaceName,
+		tables
+	});
+})).pipe(Command.withDescription("List tables"));
+const tableCommand = Command.make("table").pipe(Command.withDescription("Manage tables"), Command.withSubcommands([
+	createCommand,
+	getCommand,
+	deleteCommand,
+	listCommand
+]));
+//#endregion
+//#region src/utils/logger.ts
+const decodeJson = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown));
+const formatStructured = (value, output) => {
+	const json = Formatter.formatJson(value);
+	return output === "json" ? json : encode(decodeJson(json));
+};
+const messageValue = (message) => Array.isArray(message) && message.length === 1 ? message[0] : message;
+const structuredLogger = (output) => Logger.make(({ message }) => formatStructured(messageValue(message), output)).pipe(Logger.withConsoleLog);
+let errorFormat = "default";
+const OutputLogger = Layer.unwrap(Effect.map(Output, (output) => {
+	errorFormat = output;
+	return Logger.layer([structuredLogger(output)]);
+}));
+const encodeError = Schema.encodeSync(Schema.Defect());
+const encodeErrorWithStack = Schema.encodeSync(Schema.Defect({ includeStack: true }));
+/**
+* Prints a failed command as `error: message: ... cause: ...` instead of the stack dump
+* `runMain` prints by default.
+*
+* Says nothing about Ctrl+C, or about errors the CLI already printed itself.
+*/
+const reportError = (cause) => {
+	if (Cause.hasInterruptsOnly(cause)) return Effect.void;
+	const error = Cause.squash(cause);
+	if (!Runtime.getErrorReported(error)) return Effect.void;
+	const defect = Cause.findDefect(cause);
+	const stack = Result.isSuccess(defect) && defect.success instanceof Error ? defect.success.stack : void 0;
+	if (errorFormat === "json") {
+		const encode = stack === void 0 ? encodeError : encodeErrorWithStack;
+		return Console.error(formatStructured({ error: encode(error) }, "json"));
+	}
+	const block = formatStructured({ error: encodeError(error) }, "default");
+	return Console.error(stack === void 0 ? block : `${block}\n\n${stack}`);
+};
+//#endregion
+//#region src/index.ts
+const version = version$1;
+const program = Command.make("airfoil", {}, () => Effect.void).pipe(Command.withSubcommands([
+	catalogCommand,
+	namespaceCommand,
+	tableCommand
+]), Command.provide(OutputLogger), Command.withGlobalFlags([WingsUri, Output]));
+const cli = Command.run(program, { version });
+NodeRuntime.runMain(cli.pipe(Effect.provide(Layer.mergeAll(FetchHttpClient.layer, NodeServices.layer)), Effect.scoped, Effect.tapCause(reportError)), { disableErrorReporting: true });
+//#endregion
+export {};

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "airfoil",
-  "version": "0.4.4",
-  "repository": "useairfoil/typescript-sdk",
+  "version": "0.4.6",
+  "repository": "useairfoil/connector-kit",
   "bin": {
-    "airfoil": "./dist/index.js"
+    "airfoil": "./dist/index.mjs"
   },
   "files": [
     "dist",
@@ -11,29 +11,32 @@
     "README.md"
   ],
   "type": "module",
-  "main": "./dist/index.js",
+  "main": "./dist/index.mjs",
   "exports": {
-    ".": "./dist/index.js"
+    ".": "./dist/index.mjs"
   },
   "scripts": {
     "build": "tsdown",
+    "test": "vitest",
+    "test:ci": "vitest run",
     "typecheck": "tsc --noEmit",
     "dev": "tsx src/index.ts"
   },
   "dependencies": {
-    "@clack/prompts": "^0.11.0",
-    "@effect/platform-node": "^4.0.0-rc.108",
-    "@useairfoil/flight": "0.4.6",
-    "@useairfoil/wings": "0.4.4",
-    "console-table-printer": "^2.15.0",
-    "effect": "^4.0.0-rc.108",
-    "nice-grpc": "^2.1.13",
-    "nice-grpc-common": "^2.0.2"
+    "@effect/platform-node": "^4.0.7",
+    "@toon-format/toon": "^4.1.1",
+    "@useairfoil/effect-iceberg": "0.0.8",
+    "@useairfoil/wings": "0.4.7",
+    "effect": "^4.0.7",
+    "iceberg-js": "^1.0.0"
   },
   "devDependencies": {
+    "@effect/vitest": "^4.0.7",
     "@types/node": "^24.2.0",
-    "tsdown": "^0.15.6",
+    "@useairfoil/wings-testing": "0.1.6",
+    "tsdown": "^0.23.0",
     "tsx": "^4.21.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vitest": "^5.0.3"
   }
 }

package/src/commands/catalog.ts

@@ -0,0 +1,48 @@
+import { CatalogManager } from "@useairfoil/wings";
+import { Effect } from "effect";
+import { Argument, Command, Flag } from "effect/cli";
+
+import { parseRestCatalogConfig } from "../utils/json";
+import { WingsUri } from "../utils/options";
+
+const idArgument = Argument.String("id").pipe(Argument.withDescription("Catalog ID"));
+
+const restFlag = Flag.String("rest").pipe(
+  Flag.withDescription("Iceberg REST catalog configuration as JSON"),
+);
+
+const createCommand = Command.make("create", { id: idArgument, rest: restFlag }, ({ id, rest }) =>
+  Effect.gen(function* () {
+    const baseUrl = yield* WingsUri;
+    const manager = yield* CatalogManager.make({ baseUrl });
+    const config = yield* parseRestCatalogConfig(rest);
+    const catalog = yield* manager.createCatalog({ id, rest: config });
+
+    yield* Effect.log(catalog);
+  }),
+).pipe(Command.withDescription("Create a new catalog"));
+
+const getCommand = Command.make("get", { id: idArgument }, ({ id }) =>
+  Effect.gen(function* () {
+    const baseUrl = yield* WingsUri;
+    const manager = yield* CatalogManager.make({ baseUrl });
+    const catalog = yield* manager.getCatalog(id);
+
+    yield* Effect.log(catalog);
+  }),
+).pipe(Command.withDescription("Get a catalog"));
+
+const deleteCommand = Command.make("delete", { id: idArgument }, ({ id }) =>
+  Effect.gen(function* () {
+    const baseUrl = yield* WingsUri;
+    const manager = yield* CatalogManager.make({ baseUrl });
+
+    yield* manager.deleteCatalog(id);
+    yield* Effect.log({ id });
+  }),
+).pipe(Command.withDescription("Delete a catalog"));
+
+export const catalogCommand = Command.make("catalog").pipe(
+  Command.withDescription("Manage catalogs"),
+  Command.withSubcommands([createCommand, getCommand, deleteCommand]),
+);

package/src/commands/namespace.ts

@@ -0,0 +1,75 @@
+import { Effect, Option } from "effect";
+import { Argument, Command, Flag } from "effect/cli";
+
+import { getIcebergCatalog, parseNamespaceIdentifier } from "../utils/iceberg";
+import { catalogFlag } from "../utils/options";
+
+const namespaceArgument = Argument.String("namespace").pipe(
+  Argument.withDescription("Namespace name. Use dot-separated notation for nested namespaces"),
+);
+
+const parentFlag = Flag.String("parent").pipe(
+  Flag.withDescription("Parent namespace. Use dot-separated notation for nested namespaces"),
+  Flag.optional,
+);
+
+const createCommand = Command.make(
+  "create",
+  { namespace: namespaceArgument, catalog: catalogFlag },
+  ({ namespace, catalog }) =>
+    Effect.gen(function* () {
+      const id = yield* parseNamespaceIdentifier(namespace);
+      const iceberg = yield* getIcebergCatalog(catalog);
+      const created = yield* iceberg.createNamespace(id);
+
+      yield* Effect.log(created);
+    }),
+).pipe(Command.withDescription("Create a new namespace"));
+
+const getCommand = Command.make(
+  "get",
+  { namespace: namespaceArgument, catalog: catalogFlag },
+  ({ namespace, catalog }) =>
+    Effect.gen(function* () {
+      const id = yield* parseNamespaceIdentifier(namespace);
+      const iceberg = yield* getIcebergCatalog(catalog);
+      const metadata = yield* iceberg.loadNamespaceMetadata(id);
+
+      yield* Effect.log({ ...id, ...metadata });
+    }),
+).pipe(Command.withDescription("Get a namespace"));
+
+const deleteCommand = Command.make(
+  "delete",
+  { namespace: namespaceArgument, catalog: catalogFlag },
+  ({ namespace, catalog }) =>
+    Effect.gen(function* () {
+      const id = yield* parseNamespaceIdentifier(namespace);
+      const iceberg = yield* getIcebergCatalog(catalog);
+
+      yield* iceberg.dropNamespace(id);
+      yield* Effect.log(id);
+    }),
+).pipe(Command.withDescription("Delete a namespace"));
+
+const listCommand = Command.make(
+  "list",
+  { parent: parentFlag, catalog: catalogFlag },
+  ({ parent, catalog }) =>
+    Effect.gen(function* () {
+      const iceberg = yield* getIcebergCatalog(catalog);
+      const parentName = Option.getOrUndefined(parent);
+      const parentId =
+        parentName === undefined ? undefined : yield* parseNamespaceIdentifier(parentName);
+      const result = yield* iceberg.listNamespaces(
+        parentId === undefined ? undefined : { parent: parentId },
+      );
+
+      yield* Effect.log(result);
+    }),
+).pipe(Command.withDescription("List namespaces"));
+
+export const namespaceCommand = Command.make("namespace").pipe(
+  Command.withDescription("Manage namespaces"),
+  Command.withSubcommands([createCommand, getCommand, deleteCommand, listCommand]),
+);

package/src/commands/table.ts

@@ -0,0 +1,111 @@
+import { Effect, Option } from "effect";
+import { Argument, CliError, Command, Flag } from "effect/cli";
+
+import {
+  getIcebergCatalog,
+  listAllNamespaces,
+  listAllTables,
+  parseNamespaceIdentifier,
+  parseTableIdentifier,
+} from "../utils/iceberg";
+import { parseTableFields } from "../utils/json";
+import { catalogFlag } from "../utils/options";
+
+const tableArgument = Argument.String("table").pipe(
+  Argument.withDescription("Fully qualified table name"),
+);
+
+const namespaceArgument = Argument.String("namespace").pipe(
+  Argument.withDescription("Namespace name. Use dot-separated notation for nested namespaces"),
+  Argument.optional,
+);
+
+const allFlag = Flag.Boolean("all").pipe(
+  Flag.withDescription("List tables from all namespaces"),
+  Flag.withDefault(false),
+);
+
+const schemaFlag = Flag.String("schema").pipe(
+  Flag.withDescription("Iceberg table fields as a JSON array"),
+);
+
+const createCommand = Command.make(
+  "create",
+  { table: tableArgument, schema: schemaFlag, catalog: catalogFlag },
+  ({ table, schema, catalog }) =>
+    Effect.gen(function* () {
+      const id = yield* parseTableIdentifier(table);
+      const fields = yield* parseTableFields(schema);
+      const iceberg = yield* getIcebergCatalog(catalog);
+      const metadata = yield* iceberg.createTable(
+        { namespace: id.namespace },
+        { name: id.name, schema: { type: "struct", fields } },
+      );
+
+      yield* Effect.log({ ...id, metadata });
+    }),
+).pipe(Command.withDescription("Create a new table"));
+
+const getCommand = Command.make(
+  "get",
+  { table: tableArgument, catalog: catalogFlag },
+  ({ table, catalog }) =>
+    Effect.gen(function* () {
+      const id = yield* parseTableIdentifier(table);
+      const iceberg = yield* getIcebergCatalog(catalog);
+      const metadata = yield* iceberg.loadTable(id);
+
+      yield* Effect.log({ ...id, metadata });
+    }),
+).pipe(Command.withDescription("Get a table"));
+
+const deleteCommand = Command.make(
+  "delete",
+  { table: tableArgument, catalog: catalogFlag },
+  ({ table, catalog }) =>
+    Effect.gen(function* () {
+      const id = yield* parseTableIdentifier(table);
+      const iceberg = yield* getIcebergCatalog(catalog);
+
+      yield* iceberg.dropTable(id);
+      yield* Effect.log(id);
+    }),
+).pipe(Command.withDescription("Delete a table"));
+
+const listCommand = Command.make(
+  "list",
+  { namespace: namespaceArgument, all: allFlag, catalog: catalogFlag },
+  ({ namespace, all, catalog }) =>
+    Effect.gen(function* () {
+      const namespaceName = Option.getOrUndefined(namespace);
+
+      if (namespaceName === undefined && !all) {
+        return yield* new CliError.UserError({
+          cause: "Missing table list selector",
+          userMessage: "Provide a namespace or use --all",
+        });
+      }
+
+      if (namespaceName !== undefined && all) {
+        return yield* new CliError.UserError({
+          cause: "Conflicting table list selectors",
+          userMessage: "Provide either a namespace or --all, not both",
+        });
+      }
+
+      const iceberg = yield* getIcebergCatalog(catalog);
+      const tables =
+        namespaceName === undefined
+          ? (yield* Effect.forEach(yield* listAllNamespaces(iceberg), (namespace) =>
+              listAllTables(iceberg, namespace),
+            )).flat()
+          : yield* listAllTables(iceberg, yield* parseNamespaceIdentifier(namespaceName));
+
+      yield* Effect.log({ namespace: namespaceName, tables });
+    }),
+).pipe(Command.withDescription("List tables"));
+
+export const tableCommand = Command.make("table").pipe(
+  Command.withDescription("Manage tables"),
+  Command.withSubcommands([createCommand, getCommand, deleteCommand, listCommand]),
+);

package/src/index.ts

@@ -1,18 +1,22 @@
 #!/usr/bin/env node
 import { NodeRuntime, NodeServices } from "@effect/platform-node";
 import { Effect, Layer } from "effect";
-import { Command } from "effect/unstable/cli";
-import { FetchHttpClient } from "effect/unstable/http";
+import { Command } from "effect/cli";
+import { FetchHttpClient } from "effect/http";
 
 import packageJson from "../package.json";
-import { clusterCommand } from "./commands/cluster/index";
-import { devCommand } from "./commands/dev";
-import { sqlCommand } from "./commands/sql";
+import { catalogCommand } from "./commands/catalog";
+import { namespaceCommand } from "./commands/namespace";
+import { tableCommand } from "./commands/table";
+import { OutputLogger, reportError } from "./utils/logger";
+import { Output, WingsUri } from "./utils/options";
 
 const version = packageJson.version;
 
 const program = Command.make("airfoil", {}, () => Effect.void).pipe(
-  Command.withSubcommands([devCommand, sqlCommand, clusterCommand]),
+  Command.withSubcommands([catalogCommand, namespaceCommand, tableCommand]),
+  Command.provide(OutputLogger),
+  Command.withGlobalFlags([WingsUri, Output]),
 );
 
 const cli = Command.run(program, {
@@ -23,5 +27,7 @@ NodeRuntime.runMain(
   cli.pipe(
     Effect.provide(Layer.mergeAll(FetchHttpClient.layer, NodeServices.layer)),
     Effect.scoped,
+    Effect.tapCause(reportError),
   ),
+  { disableErrorReporting: true },
 );