airfoil 0.4.4 → 0.4.6

package/src/utils/iceberg.ts

@@ -0,0 +1,58 @@
+import type { IcebergCatalog } from "@useairfoil/effect-iceberg";
+
+import { CatalogManager } from "@useairfoil/wings";
+import { Effect, Schema } from "effect";
+
+import { WingsUri } from "./options";
+
+const NamespaceSegments = Schema.NonEmptyArray(Schema.NonEmptyString);
+const TableSegments = Schema.Array(Schema.NonEmptyString).check(Schema.isMinLength(2));
+
+export const parseNamespaceIdentifier = (name: string) =>
+  Schema.decodeUnknownEffect(NamespaceSegments)(name.split(".")).pipe(
+    Effect.map((namespace) => ({ namespace: Array.from(namespace) })),
+  );
+
+export const parseTableIdentifier = (qualifiedName: string) =>
+  Schema.decodeUnknownEffect(TableSegments)(qualifiedName.split(".")).pipe(
+    Effect.map((segments) => ({
+      namespace: segments.slice(0, -1),
+      name: segments[segments.length - 1]!,
+    })),
+  );
+
+export const getIcebergCatalog = Effect.fn("getIcebergCatalog")(function* (catalogId: string) {
+  const baseUrl = yield* WingsUri;
+  const manager = yield* CatalogManager.make({ baseUrl });
+
+  return yield* manager.getIcebergCatalog(catalogId);
+});
+
+export const listAllNamespaces = Effect.fn("listAllNamespaces")(function* (
+  iceberg: IcebergCatalog.Service,
+) {
+  let page = yield* iceberg.listNamespaces();
+  const namespaces = [...page.namespaces];
+
+  while (page.nextPageToken !== undefined) {
+    page = yield* iceberg.listNamespaces({ pageToken: page.nextPageToken });
+    namespaces.push(...page.namespaces);
+  }
+
+  return namespaces;
+});
+
+export const listAllTables = Effect.fn("listAllTables")(function* (
+  iceberg: IcebergCatalog.Service,
+  namespace: Parameters<IcebergCatalog.Service["listTables"]>[0],
+) {
+  let page = yield* iceberg.listTables(namespace);
+  const identifiers = [...page.identifiers];
+
+  while (page.nextPageToken !== undefined) {
+    page = yield* iceberg.listTables(namespace, { pageToken: page.nextPageToken });
+    identifiers.push(...page.identifiers);
+  }
+
+  return identifiers;
+});

package/src/utils/json.ts

@@ -0,0 +1,48 @@
+import type { IcebergType, TableField } from "iceberg-js";
+
+import { CatalogManager } from "@useairfoil/wings";
+import { Schema } from "effect";
+
+const RestCatalogConfigJson = Schema.fromJsonString(CatalogManager.RestCatalogConfig);
+
+const DefaultValue = Schema.Union([Schema.Boolean, Schema.Number, Schema.String]);
+
+const IcebergTypeSchema: Schema.Codec<IcebergType> = 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.Codec<TableField> = 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)));
+
+export const parseRestCatalogConfig = Schema.decodeUnknownEffect(RestCatalogConfigJson);
+
+export const parseTableFields = Schema.decodeUnknownEffect(TableFieldsJson);

package/src/utils/logger.ts

@@ -0,0 +1,67 @@
+import { encode } from "@toon-format/toon";
+import { Cause, Console, Effect, Formatter, Layer, Logger, Result, Runtime, Schema } from "effect";
+
+import { Output } from "./options";
+
+const decodeJson = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown));
+
+export type OutputFormat = "default" | "json";
+
+export const formatStructured = (value: unknown, output: OutputFormat) => {
+  const json = Formatter.formatJson(value);
+
+  return output === "json" ? json : encode(decodeJson(json));
+};
+
+const messageValue = (message: unknown) =>
+  Array.isArray(message) && message.length === 1 ? message[0] : message;
+
+const structuredLogger = (output: OutputFormat) =>
+  Logger.make<unknown, string>(({ message }) =>
+    formatStructured(messageValue(message), output),
+  ).pipe(Logger.withConsoleLog);
+
+// Errors are reported after the command ends, when its flags are gone. Keep the format here.
+let errorFormat: OutputFormat = "default";
+
+export const OutputLogger = Layer.unwrap(
+  Effect.map(Output, (output) => {
+    errorFormat = output;
+
+    return Logger.layer([structuredLogger(output)]);
+  }),
+);
+
+// Turns an error and its causes into plain JSON, so we do not walk the chain ourselves.
+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.
+ */
+export const reportError = (cause: Cause.Cause<unknown>) => {
+  if (Cause.hasInterruptsOnly(cause)) return Effect.void;
+
+  const error = Cause.squash(cause);
+
+  if (!Runtime.getErrorReported(error)) return Effect.void;
+
+  // Only an unexpected defect is worth a stack. A failure is explained by its message chain.
+  const defect = Cause.findDefect(cause);
+  const stack =
+    Result.isSuccess(defect) && defect.success instanceof Error ? defect.success.stack : undefined;
+
+  if (errorFormat === "json") {
+    const encode = stack === undefined ? encodeError : encodeErrorWithStack;
+
+    return Console.error(formatStructured({ error: encode(error) }, "json"));
+  }
+
+  // Toon has no multi-line string, so the stack only reads well under the block.
+  const block = formatStructured({ error: encodeError(error) }, "default");
+
+  return Console.error(stack === undefined ? block : `${block}\n\n${stack}`);
+};

package/src/utils/options.ts

@@ -1,35 +1,21 @@
-import { Flag } from "effect/unstable/cli";
+import { Config } from "effect";
+import { Flag, GlobalFlag } from "effect/cli";
 
-/**
- * Common server connection options
- */
-export const hostOption = Flag.string("host").pipe(
-  Flag.withDescription("Server host"),
-  Flag.withDefault("127.0.0.1"),
-);
-
-export const portOption = Flag.integer("port").pipe(
-  Flag.withDescription("Server port"),
-  Flag.withAlias("p"),
-  Flag.withDefault(7777),
-);
+export const WingsUri = GlobalFlag.Setting("uri")({
+  flag: Flag.String("uri").pipe(
+    Flag.withDefault("http://localhost:7777"),
+    Flag.withDescription("Server URI"),
+  ),
+});
 
-/**
- * Common pagination options
- */
-export const pageSizeOption = Flag.integer("page-size").pipe(
-  Flag.withDescription("Number of items to return (max: 1000)"),
-  Flag.withDefault(100),
-);
-
-export const pageTokenOption = Flag.optional(
-  Flag.string("page-token").pipe(Flag.withDescription("Continuation token for pagination")),
-);
+export const Output = GlobalFlag.Setting("output")({
+  flag: Flag.Literals("output", ["default", "json"] as const).pipe(
+    Flag.withDefault("default"),
+    Flag.withDescription("Log output format"),
+  ),
+});
 
-/**
- * Force flag for destructive operations
- */
-export const forceOption = Flag.boolean("force").pipe(
-  Flag.withDescription("Skip confirmation prompt"),
-  Flag.withDefault(false),
+export const catalogFlag = Flag.String("catalog").pipe(
+  Flag.withDescription("Catalog ID. Alternatively, use the AIRFOIL_CATALOG environment variable"),
+  Flag.withFallbackConfig(Config.NonEmptyString("AIRFOIL_CATALOG")),
 );