@useairfoil/effect-iceberg 0.0.0 → 0.0.1

package/README.md

@@ -0,0 +1,207 @@
+# @useairfoil/effect-iceberg
+
+Effect wrapper for [`iceberg-js`](https://github.com/supabase/iceberg-js), the Apache Iceberg REST Catalog client.
+
+This package provides an Effect service, layers, accessors, and typed errors around `iceberg-js`. It does not replace the `iceberg-js` API or type surface. Import Apache Iceberg domain types directly from `iceberg-js`.
+
+## Install
+
+```sh
+pnpm add @useairfoil/effect-iceberg iceberg-js effect
+```
+
+`iceberg-js` and `effect` are peer dependencies so your application owns their versions.
+
+## Imports
+
+```typescript
+import { IcebergCatalog, IcebergError } from "@useairfoil/effect-iceberg";
+import type { CreateTableRequest, TableIdentifier } from "iceberg-js";
+```
+
+`@useairfoil/effect-iceberg` exports wrapper modules only:
+
+- `IcebergCatalog` contains the service tag, constructors, layers, and accessor functions.
+- `IcebergError` contains the Effect error type and mapper for failures from `iceberg-js`.
+
+Use `iceberg-js` directly for catalog options, request/response types, metadata types, table update unions, and helpers.
+
+## Layer
+
+Create a layer from normal `iceberg-js` catalog options:
+
+```typescript
+import { IcebergCatalog } from "@useairfoil/effect-iceberg";
+
+const IcebergLive = IcebergCatalog.layer({
+  baseUrl: "https://catalog.example.com",
+  warehouse: "warehouse",
+  auth: { type: "bearer", token: process.env.ICEBERG_TOKEN ?? "" },
+  accessDelegation: ["vended-credentials"],
+});
+```
+
+Or build a layer from Effect `Config` values:
+
+```typescript
+import { Config } from "effect";
+import { IcebergCatalog } from "@useairfoil/effect-iceberg";
+import type { AuthConfig } from "iceberg-js";
+
+const IcebergLive = IcebergCatalog.layerConfig({
+  baseUrl: Config.string("ICEBERG_REST_URL"),
+  warehouse: Config.string("ICEBERG_WAREHOUSE"),
+  auth: Config.string("ICEBERG_TOKEN").pipe(
+    Config.map((token): AuthConfig => ({ type: "bearer", token })),
+  ),
+});
+```
+
+## Usage
+
+Use the accessor functions for most application code. They read the `IcebergCatalog` service from the Effect context and delegate to the underlying `iceberg-js` client.
+
+```typescript
+import { Effect } from "effect";
+import { IcebergCatalog } from "@useairfoil/effect-iceberg";
+import type { TableIdentifier } from "iceberg-js";
+
+const IcebergLive = IcebergCatalog.layer({
+  baseUrl: "https://catalog.example.com",
+  warehouse: "warehouse",
+  auth: { type: "bearer", token: process.env.ICEBERG_TOKEN ?? "" },
+});
+
+const program = Effect.gen(function* () {
+  const id: TableIdentifier = { namespace: ["analytics"], name: "events" };
+  return yield* IcebergCatalog.loadTable(id);
+});
+
+await Effect.runPromise(program.pipe(Effect.provide(IcebergLive)));
+```
+
+## Catalog Operations
+
+The `IcebergCatalog` module mirrors the public `iceberg-js` `IcebergRestCatalog` methods as Effect accessors:
+
+```typescript
+const program = Effect.gen(function* () {
+  const namespaces = yield* IcebergCatalog.listNamespaces();
+
+  const tables = yield* IcebergCatalog.listTables({ namespace: ["analytics"] });
+
+  const table = yield* IcebergCatalog.loadTable({
+    namespace: ["analytics"],
+    name: "events",
+  });
+
+  return { namespaces, tables, table };
+});
+```
+
+Create tables with request types from `iceberg-js`:
+
+```typescript
+import type { CreateTableRequest } from "iceberg-js";
+
+const request: CreateTableRequest = {
+  name: "events",
+  schema: {
+    type: "struct",
+    "schema-id": 0,
+    fields: [{ id: 1, name: "id", type: "string", required: true }],
+  },
+};
+
+const program = Effect.gen(function* () {
+  return yield* IcebergCatalog.createTable({ namespace: ["analytics"] }, request);
+});
+```
+
+Use `loadTableResult`, `createTableResult`, or `registerTableResult` when you need the full spec-aligned result, including server config, storage credentials, metadata location, and ETag:
+
+```typescript
+const program = Effect.gen(function* () {
+  const result = yield* IcebergCatalog.loadTableResult({
+    namespace: ["analytics"],
+    name: "events",
+  });
+
+  if (result) {
+    console.log(result.etag);
+    console.log(result["storage-credentials"]);
+  }
+
+  return result;
+});
+```
+
+Conditional table loads return `null` when the server responds with `304 Not Modified`:
+
+```typescript
+const program = Effect.gen(function* () {
+  return yield* IcebergCatalog.loadTable(
+    { namespace: ["analytics"], name: "events" },
+    { ifNoneMatch: "abc123" },
+  );
+});
+```
+
+## Service Access
+
+For advanced use cases, access the service directly. This is useful when you want the underlying `iceberg-js` client or want to call several methods from one service value.
+
+```typescript
+const program = Effect.gen(function* () {
+  const catalog = yield* IcebergCatalog.IcebergCatalog;
+  const client = catalog.getCatalogClient();
+
+  yield* catalog.loadConfig();
+  return client;
+});
+```
+
+## Errors
+
+Failures thrown by `iceberg-js` are mapped to `IcebergError.IcebergError`. The wrapper preserves the important Iceberg fields: HTTP `status`, Iceberg exception `type` / `code`, `details`, and `isCommitStateUnknown`.
+
+```typescript
+import { Effect } from "effect";
+import { IcebergError } from "@useairfoil/effect-iceberg";
+
+const handled = program.pipe(
+  Effect.catchTag("IcebergError", (error: IcebergError.IcebergError) =>
+    Effect.succeed({ status: error.status, type: error.icebergType }),
+  ),
+);
+```
+
+You can also inspect commit-state ambiguity from the Iceberg REST spec:
+
+```typescript
+const safeCommit = IcebergCatalog.commitTable(id, request).pipe(
+  Effect.catchTag("IcebergError", (error) => {
+    if (error.isCommitStateUnknown) {
+      return Effect.fail(error);
+    }
+    return Effect.fail(error);
+  }),
+);
+```
+
+## Direct `iceberg-js` Types
+
+Keep domain types close to `iceberg-js`:
+
+```typescript
+import type {
+  CommitTableRequest,
+  LoadTableResultWithEtag,
+  NamespaceIdentifier,
+  TableIdentifier,
+  TableMetadata,
+  TableUpdate,
+} from "iceberg-js";
+```
+
+This keeps your application aligned with the exact `iceberg-js` version you install, while `@useairfoil/effect-iceberg` provides the Effect integration layer.

package/dist/chunk-Bp6m_JJh.js

@@ -0,0 +1,13 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (all) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+
+//#endregion
+export { __export as t };

package/dist/index.d.ts

@@ -0,0 +1,133 @@
+import { Config, Context, Effect, Layer } from "effect";
+import { CatalogConfig, CommitTableRequest, CommitTableResponse, CreateNamespaceResponse, CreateTableRequest, DropTableRequest, IcebergRestCatalog, IcebergRestCatalogOptions, ListNamespacesOptions, ListNamespacesResult, ListTablesOptions, ListTablesResult, LoadTableOptions, LoadTableResultWithEtag, NamespaceIdentifier, NamespaceMetadata, RegisterTableRequest, RenameTableRequest, TableIdentifier, TableMetadata, UpdateNamespacePropertiesRequest, UpdateNamespacePropertiesResponse, UpdateTableRequest } from "iceberg-js";
+import * as effect_Types0 from "effect/Types";
+import * as effect_Cause0 from "effect/Cause";
+
+//#region src/errors.d.ts
+declare namespace errors_d_exports {
+  export { IcebergError$1 as IcebergError, mapIcebergError };
+}
+declare const IcebergError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => effect_Cause0.YieldableError & {
+  readonly _tag: "IcebergError";
+} & Readonly<A>;
+/** Error type used by the Effect wrapper around `iceberg-js`. */
+declare class IcebergError$1 extends IcebergError_base<{
+  readonly message: string;
+  readonly status?: number;
+  readonly icebergType?: string;
+  readonly icebergCode?: number;
+  readonly details?: unknown;
+  readonly isCommitStateUnknown?: boolean;
+  readonly cause?: unknown;
+}> {}
+/** Maps errors thrown by `iceberg-js` into `IcebergError`. */
+declare const mapIcebergError: (error: unknown) => IcebergError$1;
+declare namespace catalog_d_exports {
+  export { IcebergCatalog, Service, commitTable, createNamespace, createNamespaceIfNotExists, createTable, createTableIfNotExists, createTableResult, dropNamespace, dropTable, getCatalogClient, layer, layerConfig, listNamespaces, listTables, loadConfig, loadNamespaceMetadata, loadTable, loadTableResult, make, namespaceExists, registerTable, registerTableResult, renameTable, tableExists, updateNamespaceProperties, updateTable };
+}
+interface Service {
+  /**
+   * Returns the underlying `iceberg-js` catalog client.
+   *
+   * Use this for advanced cases that need direct access to the Promise-based API.
+   */
+  readonly getCatalogClient: () => IcebergRestCatalog;
+  /**
+   * Fetch and cache the server's catalog configuration. Calling this is optional;
+   * catalog operations trigger it lazily when a warehouse is configured.
+   */
+  readonly loadConfig: () => Effect.Effect<CatalogConfig, IcebergError$1>;
+  /** Lists all namespaces in the catalog. */
+  readonly listNamespaces: (options?: ListNamespacesOptions) => Effect.Effect<ListNamespacesResult, IcebergError$1>;
+  /** Creates a new namespace in the catalog. */
+  readonly createNamespace: (id: NamespaceIdentifier, metadata?: NamespaceMetadata) => Effect.Effect<CreateNamespaceResponse, IcebergError$1>;
+  /**
+   * Drops a namespace from the catalog.
+   *
+   * The namespace must be empty before it can be dropped.
+   */
+  readonly dropNamespace: (id: NamespaceIdentifier) => Effect.Effect<void, IcebergError$1>;
+  /** Loads metadata for a namespace. */
+  readonly loadNamespaceMetadata: (id: NamespaceIdentifier) => Effect.Effect<NamespaceMetadata, IcebergError$1>;
+  /** Sets or removes properties on a namespace. */
+  readonly updateNamespaceProperties: (id: NamespaceIdentifier, request: UpdateNamespacePropertiesRequest) => Effect.Effect<UpdateNamespacePropertiesResponse, IcebergError$1>;
+  /** Lists tables in a namespace. */
+  readonly listTables: (namespace: NamespaceIdentifier, options?: ListTablesOptions) => Effect.Effect<ListTablesResult, IcebergError$1>;
+  /** Creates a new table in the catalog. */
+  readonly createTable: (namespace: NamespaceIdentifier, request: CreateTableRequest) => Effect.Effect<TableMetadata, IcebergError$1>;
+  /**
+   * Creates a table and returns the full spec-aligned `LoadTableResult`, including
+   * server config, storage credentials, and the response ETag.
+   */
+  readonly createTableResult: (namespace: NamespaceIdentifier, request: CreateTableRequest) => Effect.Effect<LoadTableResultWithEtag, IcebergError$1>;
+  /** Commits updates to a table using the spec-aligned `{ requirements, updates }` shape. */
+  readonly updateTable: (id: TableIdentifier, request: UpdateTableRequest) => Effect.Effect<CommitTableResponse, IcebergError$1>;
+  /** Spec-aligned alias for `updateTable`. */
+  readonly commitTable: (id: TableIdentifier, request: CommitTableRequest) => Effect.Effect<CommitTableResponse, IcebergError$1>;
+  /** Drops a table from the catalog. */
+  readonly dropTable: (id: TableIdentifier, options?: DropTableRequest) => Effect.Effect<void, IcebergError$1>;
+  /**
+   * Loads metadata for a table.
+   *
+   * Pass `ifNoneMatch` in options to perform a conditional GET. If the server
+   * returns 304 Not Modified, the result is `null`.
+   */
+  readonly loadTable: {
+    (id: TableIdentifier): Effect.Effect<TableMetadata, IcebergError$1>;
+    (id: TableIdentifier, options: LoadTableOptions): Effect.Effect<TableMetadata | null, IcebergError$1>;
+  };
+  /**
+   * Loads the full spec-aligned `LoadTableResult`, including server config,
+   * storage credentials, and the response ETag. Returns `null` on 304.
+   */
+  readonly loadTableResult: (id: TableIdentifier, options?: LoadTableOptions) => Effect.Effect<LoadTableResultWithEtag | null, IcebergError$1>;
+  /** Checks if a namespace exists in the catalog. */
+  readonly namespaceExists: (id: NamespaceIdentifier) => Effect.Effect<boolean, IcebergError$1>;
+  /** Checks if a table exists in the catalog. */
+  readonly tableExists: (id: TableIdentifier) => Effect.Effect<boolean, IcebergError$1>;
+  /** Creates a namespace if it does not exist. */
+  readonly createNamespaceIfNotExists: (id: NamespaceIdentifier, metadata?: NamespaceMetadata) => Effect.Effect<CreateNamespaceResponse | void, IcebergError$1>;
+  /** Creates a table if it does not exist. */
+  readonly createTableIfNotExists: (namespace: NamespaceIdentifier, request: CreateTableRequest) => Effect.Effect<TableMetadata, IcebergError$1>;
+  /** Registers an existing metadata file as a table in the given namespace. */
+  readonly registerTable: (namespace: NamespaceIdentifier, request: RegisterTableRequest) => Effect.Effect<TableMetadata, IcebergError$1>;
+  /** Returns the full spec-aligned `LoadTableResult` for `registerTable`. */
+  readonly registerTableResult: (namespace: NamespaceIdentifier, request: RegisterTableRequest) => Effect.Effect<LoadTableResultWithEtag, IcebergError$1>;
+  /** Renames a table. Servers may or may not support cross-namespace renames. */
+  readonly renameTable: (request: RenameTableRequest) => Effect.Effect<void, IcebergError$1>;
+}
+declare const IcebergCatalog_base: Context.ServiceClass<IcebergCatalog, "@useairfoil/effect-iceberg/IcebergCatalog", Service>;
+/** Service for the Effect wrapper around `iceberg-js`'s `IcebergRestCatalog`. */
+declare class IcebergCatalog extends IcebergCatalog_base {}
+/** Creates an `IcebergCatalog` service from `iceberg-js` catalog options. */
+declare const make: (options: IcebergRestCatalogOptions) => Service;
+declare const getCatalogClient: Effect.Effect<IcebergRestCatalog, never, IcebergCatalog>;
+declare const loadConfig: Effect.Effect<CatalogConfig, IcebergError$1, IcebergCatalog>;
+declare const listNamespaces: (options?: ListNamespacesOptions) => Effect.Effect<ListNamespacesResult, IcebergError$1, IcebergCatalog>;
+declare const createNamespace: (id: NamespaceIdentifier, metadata?: NamespaceMetadata) => Effect.Effect<CreateNamespaceResponse, IcebergError$1, IcebergCatalog>;
+declare const dropNamespace: (id: NamespaceIdentifier) => Effect.Effect<void, IcebergError$1, IcebergCatalog>;
+declare const loadNamespaceMetadata: (id: NamespaceIdentifier) => Effect.Effect<NamespaceMetadata, IcebergError$1, IcebergCatalog>;
+declare const updateNamespaceProperties: (id: NamespaceIdentifier, request: UpdateNamespacePropertiesRequest) => Effect.Effect<UpdateNamespacePropertiesResponse, IcebergError$1, IcebergCatalog>;
+declare const listTables: (namespace: NamespaceIdentifier, options?: ListTablesOptions) => Effect.Effect<ListTablesResult, IcebergError$1, IcebergCatalog>;
+declare const createTable: (namespace: NamespaceIdentifier, request: CreateTableRequest) => Effect.Effect<TableMetadata, IcebergError$1, IcebergCatalog>;
+declare const createTableResult: (namespace: NamespaceIdentifier, request: CreateTableRequest) => Effect.Effect<LoadTableResultWithEtag, IcebergError$1, IcebergCatalog>;
+declare const updateTable: (id: TableIdentifier, request: UpdateTableRequest) => Effect.Effect<CommitTableResponse, IcebergError$1, IcebergCatalog>;
+declare const commitTable: (id: TableIdentifier, request: CommitTableRequest) => Effect.Effect<CommitTableResponse, IcebergError$1, IcebergCatalog>;
+declare const dropTable: (id: TableIdentifier, options?: DropTableRequest) => Effect.Effect<void, IcebergError$1, IcebergCatalog>;
+declare function loadTable(id: TableIdentifier): Effect.Effect<TableMetadata, IcebergError$1, IcebergCatalog>;
+declare function loadTable(id: TableIdentifier, options: LoadTableOptions): Effect.Effect<TableMetadata | null, IcebergError$1, IcebergCatalog>;
+declare const loadTableResult: (id: TableIdentifier, options?: LoadTableOptions) => Effect.Effect<LoadTableResultWithEtag | null, IcebergError$1, IcebergCatalog>;
+declare const namespaceExists: (id: NamespaceIdentifier) => Effect.Effect<boolean, IcebergError$1, IcebergCatalog>;
+declare const tableExists: (id: TableIdentifier) => Effect.Effect<boolean, IcebergError$1, IcebergCatalog>;
+declare const createNamespaceIfNotExists: (id: NamespaceIdentifier, metadata?: NamespaceMetadata) => Effect.Effect<CreateNamespaceResponse | void, IcebergError$1, IcebergCatalog>;
+declare const createTableIfNotExists: (namespace: NamespaceIdentifier, request: CreateTableRequest) => Effect.Effect<TableMetadata, IcebergError$1, IcebergCatalog>;
+declare const registerTable: (namespace: NamespaceIdentifier, request: RegisterTableRequest) => Effect.Effect<TableMetadata, IcebergError$1, IcebergCatalog>;
+declare const registerTableResult: (namespace: NamespaceIdentifier, request: RegisterTableRequest) => Effect.Effect<LoadTableResultWithEtag, IcebergError$1, IcebergCatalog>;
+declare const renameTable: (request: RenameTableRequest) => Effect.Effect<void, IcebergError$1, IcebergCatalog>;
+/** Creates an `IcebergCatalog` layer from concrete `iceberg-js` catalog options. */
+declare const layer: (options: IcebergRestCatalogOptions) => Layer.Layer<IcebergCatalog>;
+/** Creates an `IcebergCatalog` layer from Effect `Config` values. */
+declare const layerConfig: (config: Config.Wrap<IcebergRestCatalogOptions>) => Layer.Layer<IcebergCatalog, Config.ConfigError>;
+//#endregion
+export { catalog_d_exports as IcebergCatalog, errors_d_exports as IcebergError };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,130 @@
+import { t as __export } from "./chunk-Bp6m_JJh.js";
+import { Config, Context, Data, Effect, Layer } from "effect";
+import { IcebergError, IcebergRestCatalog } from "iceberg-js";
+
+//#region src/errors.ts
+var errors_exports = /* @__PURE__ */ __export({
+	IcebergError: () => IcebergError$1,
+	mapIcebergError: () => mapIcebergError
+});
+/** Error type used by the Effect wrapper around `iceberg-js`. */
+var IcebergError$1 = class extends Data.TaggedError("IcebergError") {};
+/** Maps errors thrown by `iceberg-js` into `IcebergError`. */
+const mapIcebergError = (error) => {
+	if (error instanceof IcebergError) return new IcebergError$1({
+		message: error.message,
+		status: error.status,
+		icebergType: error.icebergType,
+		icebergCode: error.icebergCode,
+		details: error.details,
+		isCommitStateUnknown: error.isCommitStateUnknown,
+		cause: error
+	});
+	return new IcebergError$1({
+		message: error instanceof Error ? error.message : String(error),
+		cause: error
+	});
+};
+
+//#endregion
+//#region src/catalog.ts
+var catalog_exports = /* @__PURE__ */ __export({
+	IcebergCatalog: () => IcebergCatalog,
+	commitTable: () => commitTable,
+	createNamespace: () => createNamespace,
+	createNamespaceIfNotExists: () => createNamespaceIfNotExists,
+	createTable: () => createTable,
+	createTableIfNotExists: () => createTableIfNotExists,
+	createTableResult: () => createTableResult,
+	dropNamespace: () => dropNamespace,
+	dropTable: () => dropTable,
+	getCatalogClient: () => getCatalogClient,
+	layer: () => layer,
+	layerConfig: () => layerConfig,
+	listNamespaces: () => listNamespaces,
+	listTables: () => listTables,
+	loadConfig: () => loadConfig,
+	loadNamespaceMetadata: () => loadNamespaceMetadata,
+	loadTable: () => loadTable,
+	loadTableResult: () => loadTableResult,
+	make: () => make,
+	namespaceExists: () => namespaceExists,
+	registerTable: () => registerTable,
+	registerTableResult: () => registerTableResult,
+	renameTable: () => renameTable,
+	tableExists: () => tableExists,
+	updateNamespaceProperties: () => updateNamespaceProperties,
+	updateTable: () => updateTable
+});
+/** Service for the Effect wrapper around `iceberg-js`'s `IcebergRestCatalog`. */
+var IcebergCatalog = class extends Context.Service()("@useairfoil/effect-iceberg/IcebergCatalog") {};
+const tryCatalog = (evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: mapIcebergError
+});
+/** Creates an `IcebergCatalog` service from `iceberg-js` catalog options. */
+const make = (options) => {
+	const catalog = new IcebergRestCatalog(options);
+	function loadTable$1(id, loadOptions) {
+		return tryCatalog(() => loadOptions === void 0 ? catalog.loadTable(id) : catalog.loadTable(id, loadOptions));
+	}
+	return IcebergCatalog.of({
+		getCatalogClient: () => catalog,
+		loadConfig: () => tryCatalog(() => catalog.loadConfig()),
+		listNamespaces: (listOptions) => tryCatalog(() => catalog.listNamespaces(listOptions)),
+		createNamespace: (id, metadata) => tryCatalog(() => catalog.createNamespace(id, metadata)),
+		dropNamespace: (id) => tryCatalog(() => catalog.dropNamespace(id)),
+		loadNamespaceMetadata: (id) => tryCatalog(() => catalog.loadNamespaceMetadata(id)),
+		updateNamespaceProperties: (id, request) => tryCatalog(() => catalog.updateNamespaceProperties(id, request)),
+		listTables: (namespace, listOptions) => tryCatalog(() => catalog.listTables(namespace, listOptions)),
+		createTable: (namespace, request) => tryCatalog(() => catalog.createTable(namespace, request)),
+		createTableResult: (namespace, request) => tryCatalog(() => catalog.createTableResult(namespace, request)),
+		updateTable: (id, request) => tryCatalog(() => catalog.updateTable(id, request)),
+		commitTable: (id, request) => tryCatalog(() => catalog.commitTable(id, request)),
+		dropTable: (id, dropOptions) => tryCatalog(() => catalog.dropTable(id, dropOptions)),
+		loadTable: loadTable$1,
+		loadTableResult: (id, loadOptions) => tryCatalog(() => catalog.loadTableResult(id, loadOptions)),
+		namespaceExists: (id) => tryCatalog(() => catalog.namespaceExists(id)),
+		tableExists: (id) => tryCatalog(() => catalog.tableExists(id)),
+		createNamespaceIfNotExists: (id, metadata) => tryCatalog(() => catalog.createNamespaceIfNotExists(id, metadata)),
+		createTableIfNotExists: (namespace, request) => tryCatalog(() => catalog.createTableIfNotExists(namespace, request)),
+		registerTable: (namespace, request) => tryCatalog(() => catalog.registerTable(namespace, request)),
+		registerTableResult: (namespace, request) => tryCatalog(() => catalog.registerTableResult(namespace, request)),
+		renameTable: (request) => tryCatalog(() => catalog.renameTable(request))
+	});
+};
+const service = Effect.service(IcebergCatalog);
+const getCatalogClient = Effect.map(service, (catalog) => catalog.getCatalogClient());
+const loadConfig = Effect.flatMap(service, (catalog) => catalog.loadConfig());
+const listNamespaces = (options) => Effect.flatMap(service, (catalog) => catalog.listNamespaces(options));
+const createNamespace = (id, metadata) => Effect.flatMap(service, (catalog) => catalog.createNamespace(id, metadata));
+const dropNamespace = (id) => Effect.flatMap(service, (catalog) => catalog.dropNamespace(id));
+const loadNamespaceMetadata = (id) => Effect.flatMap(service, (catalog) => catalog.loadNamespaceMetadata(id));
+const updateNamespaceProperties = (id, request) => Effect.flatMap(service, (catalog) => catalog.updateNamespaceProperties(id, request));
+const listTables = (namespace, options) => Effect.flatMap(service, (catalog) => catalog.listTables(namespace, options));
+const createTable = (namespace, request) => Effect.flatMap(service, (catalog) => catalog.createTable(namespace, request));
+const createTableResult = (namespace, request) => Effect.flatMap(service, (catalog) => catalog.createTableResult(namespace, request));
+const updateTable = (id, request) => Effect.flatMap(service, (catalog) => catalog.updateTable(id, request));
+const commitTable = (id, request) => Effect.flatMap(service, (catalog) => catalog.commitTable(id, request));
+const dropTable = (id, options) => Effect.flatMap(service, (catalog) => catalog.dropTable(id, options));
+function loadTable(id, options) {
+	return Effect.flatMap(service, (catalog) => options === void 0 ? catalog.loadTable(id) : catalog.loadTable(id, options));
+}
+const loadTableResult = (id, options) => Effect.flatMap(service, (catalog) => catalog.loadTableResult(id, options));
+const namespaceExists = (id) => Effect.flatMap(service, (catalog) => catalog.namespaceExists(id));
+const tableExists = (id) => Effect.flatMap(service, (catalog) => catalog.tableExists(id));
+const createNamespaceIfNotExists = (id, metadata) => Effect.flatMap(service, (catalog) => catalog.createNamespaceIfNotExists(id, metadata));
+const createTableIfNotExists = (namespace, request) => Effect.flatMap(service, (catalog) => catalog.createTableIfNotExists(namespace, request));
+const registerTable = (namespace, request) => Effect.flatMap(service, (catalog) => catalog.registerTable(namespace, request));
+const registerTableResult = (namespace, request) => Effect.flatMap(service, (catalog) => catalog.registerTableResult(namespace, request));
+const renameTable = (request) => Effect.flatMap(service, (catalog) => catalog.renameTable(request));
+/** Creates an `IcebergCatalog` layer from concrete `iceberg-js` catalog options. */
+const layer = (options) => Layer.succeed(IcebergCatalog)(make(options));
+/** Creates an `IcebergCatalog` layer from Effect `Config` values. */
+const layerConfig = (config) => Layer.effect(IcebergCatalog, Effect.gen(function* () {
+	return make(yield* Config.unwrap(config));
+}));
+
+//#endregion
+export { catalog_exports as IcebergCatalog, errors_exports as IcebergError };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["IcebergError","IcebergJsError","loadTable","getCatalogClient: Effect.Effect<IcebergRestCatalog, never, IcebergCatalog>","loadConfig: Effect.Effect<CatalogConfig, IcebergError, IcebergCatalog>"],"sources":["../src/errors.ts","../src/catalog.ts"],"sourcesContent":["import { Data } from \"effect\";\nimport { IcebergError as IcebergJsError } from \"iceberg-js\";\n\n/** Error type used by the Effect wrapper around `iceberg-js`. */\nexport class IcebergError extends Data.TaggedError(\"IcebergError\")<{\n  readonly message: string;\n  readonly status?: number;\n  readonly icebergType?: string;\n  readonly icebergCode?: number;\n  readonly details?: unknown;\n  readonly isCommitStateUnknown?: boolean;\n  readonly cause?: unknown;\n}> {}\n\n/** Maps errors thrown by `iceberg-js` into `IcebergError`. */\nexport const mapIcebergError = (error: unknown): IcebergError => {\n  if (error instanceof IcebergJsError) {\n    return new IcebergError({\n      message: error.message,\n      status: error.status,\n      icebergType: error.icebergType,\n      icebergCode: error.icebergCode,\n      details: error.details,\n      isCommitStateUnknown: error.isCommitStateUnknown,\n      cause: error,\n    });\n  }\n\n  return new IcebergError({\n    message: error instanceof Error ? error.message : String(error),\n    cause: error,\n  });\n};\n","import type {\n  CatalogConfig,\n  CommitTableRequest,\n  CommitTableResponse,\n  CreateNamespaceResponse,\n  CreateTableRequest,\n  DropTableRequest,\n  IcebergRestCatalogOptions,\n  ListNamespacesOptions,\n  ListNamespacesResult,\n  ListTablesOptions,\n  ListTablesResult,\n  LoadTableOptions,\n  LoadTableResultWithEtag,\n  NamespaceIdentifier,\n  NamespaceMetadata,\n  RegisterTableRequest,\n  RenameTableRequest,\n  TableIdentifier,\n  TableMetadata,\n  UpdateNamespacePropertiesRequest,\n  UpdateNamespacePropertiesResponse,\n  UpdateTableRequest,\n} from \"iceberg-js\";\n\nimport { Config, Context, Effect, Layer } from \"effect\";\nimport { IcebergRestCatalog } from \"iceberg-js\";\n\nimport type { IcebergError } from \"./errors\";\n\nimport { mapIcebergError } from \"./errors\";\n\nexport interface Service {\n  /**\n   * Returns the underlying `iceberg-js` catalog client.\n   *\n   * Use this for advanced cases that need direct access to the Promise-based API.\n   */\n  readonly getCatalogClient: () => IcebergRestCatalog;\n\n  /**\n   * Fetch and cache the server's catalog configuration. Calling this is optional;\n   * catalog operations trigger it lazily when a warehouse is configured.\n   */\n  readonly loadConfig: () => Effect.Effect<CatalogConfig, IcebergError>;\n\n  /** Lists all namespaces in the catalog. */\n  readonly listNamespaces: (\n    options?: ListNamespacesOptions,\n  ) => Effect.Effect<ListNamespacesResult, IcebergError>;\n\n  /** Creates a new namespace in the catalog. */\n  readonly createNamespace: (\n    id: NamespaceIdentifier,\n    metadata?: NamespaceMetadata,\n  ) => Effect.Effect<CreateNamespaceResponse, IcebergError>;\n\n  /**\n   * Drops a namespace from the catalog.\n   *\n   * The namespace must be empty before it can be dropped.\n   */\n  readonly dropNamespace: (id: NamespaceIdentifier) => Effect.Effect<void, IcebergError>;\n\n  /** Loads metadata for a namespace. */\n  readonly loadNamespaceMetadata: (\n    id: NamespaceIdentifier,\n  ) => Effect.Effect<NamespaceMetadata, IcebergError>;\n\n  /** Sets or removes properties on a namespace. */\n  readonly updateNamespaceProperties: (\n    id: NamespaceIdentifier,\n    request: UpdateNamespacePropertiesRequest,\n  ) => Effect.Effect<UpdateNamespacePropertiesResponse, IcebergError>;\n\n  /** Lists tables in a namespace. */\n  readonly listTables: (\n    namespace: NamespaceIdentifier,\n    options?: ListTablesOptions,\n  ) => Effect.Effect<ListTablesResult, IcebergError>;\n\n  /** Creates a new table in the catalog. */\n  readonly createTable: (\n    namespace: NamespaceIdentifier,\n    request: CreateTableRequest,\n  ) => Effect.Effect<TableMetadata, IcebergError>;\n\n  /**\n   * Creates a table and returns the full spec-aligned `LoadTableResult`, including\n   * server config, storage credentials, and the response ETag.\n   */\n  readonly createTableResult: (\n    namespace: NamespaceIdentifier,\n    request: CreateTableRequest,\n  ) => Effect.Effect<LoadTableResultWithEtag, IcebergError>;\n\n  /** Commits updates to a table using the spec-aligned `{ requirements, updates }` shape. */\n  readonly updateTable: (\n    id: TableIdentifier,\n    request: UpdateTableRequest,\n  ) => Effect.Effect<CommitTableResponse, IcebergError>;\n\n  /** Spec-aligned alias for `updateTable`. */\n  readonly commitTable: (\n    id: TableIdentifier,\n    request: CommitTableRequest,\n  ) => Effect.Effect<CommitTableResponse, IcebergError>;\n\n  /** Drops a table from the catalog. */\n  readonly dropTable: (\n    id: TableIdentifier,\n    options?: DropTableRequest,\n  ) => Effect.Effect<void, IcebergError>;\n\n  /**\n   * Loads metadata for a table.\n   *\n   * Pass `ifNoneMatch` in options to perform a conditional GET. If the server\n   * returns 304 Not Modified, the result is `null`.\n   */\n  readonly loadTable: {\n    (id: TableIdentifier): Effect.Effect<TableMetadata, IcebergError>;\n    (\n      id: TableIdentifier,\n      options: LoadTableOptions,\n    ): Effect.Effect<TableMetadata | null, IcebergError>;\n  };\n\n  /**\n   * Loads the full spec-aligned `LoadTableResult`, including server config,\n   * storage credentials, and the response ETag. Returns `null` on 304.\n   */\n  readonly loadTableResult: (\n    id: TableIdentifier,\n    options?: LoadTableOptions,\n  ) => Effect.Effect<LoadTableResultWithEtag | null, IcebergError>;\n\n  /** Checks if a namespace exists in the catalog. */\n  readonly namespaceExists: (id: NamespaceIdentifier) => Effect.Effect<boolean, IcebergError>;\n\n  /** Checks if a table exists in the catalog. */\n  readonly tableExists: (id: TableIdentifier) => Effect.Effect<boolean, IcebergError>;\n\n  /** Creates a namespace if it does not exist. */\n  readonly createNamespaceIfNotExists: (\n    id: NamespaceIdentifier,\n    metadata?: NamespaceMetadata,\n  ) => Effect.Effect<CreateNamespaceResponse | void, IcebergError>;\n\n  /** Creates a table if it does not exist. */\n  readonly createTableIfNotExists: (\n    namespace: NamespaceIdentifier,\n    request: CreateTableRequest,\n  ) => Effect.Effect<TableMetadata, IcebergError>;\n\n  /** Registers an existing metadata file as a table in the given namespace. */\n  readonly registerTable: (\n    namespace: NamespaceIdentifier,\n    request: RegisterTableRequest,\n  ) => Effect.Effect<TableMetadata, IcebergError>;\n\n  /** Returns the full spec-aligned `LoadTableResult` for `registerTable`. */\n  readonly registerTableResult: (\n    namespace: NamespaceIdentifier,\n    request: RegisterTableRequest,\n  ) => Effect.Effect<LoadTableResultWithEtag, IcebergError>;\n\n  /** Renames a table. Servers may or may not support cross-namespace renames. */\n  readonly renameTable: (request: RenameTableRequest) => Effect.Effect<void, IcebergError>;\n}\n\n/** Service for the Effect wrapper around `iceberg-js`'s `IcebergRestCatalog`. */\nexport class IcebergCatalog extends Context.Service<IcebergCatalog, Service>()(\n  \"@useairfoil/effect-iceberg/IcebergCatalog\",\n) {}\n\nconst tryCatalog = <A>(evaluate: () => Promise<A>): Effect.Effect<A, IcebergError> =>\n  Effect.tryPromise({\n    try: evaluate,\n    catch: mapIcebergError,\n  });\n\n/** Creates an `IcebergCatalog` service from `iceberg-js` catalog options. */\nexport const make = (options: IcebergRestCatalogOptions): Service => {\n  const catalog = new IcebergRestCatalog(options);\n\n  function loadTable(id: TableIdentifier): Effect.Effect<TableMetadata, IcebergError>;\n  function loadTable(\n    id: TableIdentifier,\n    loadOptions: LoadTableOptions,\n  ): Effect.Effect<TableMetadata | null, IcebergError>;\n  function loadTable(id: TableIdentifier, loadOptions?: LoadTableOptions) {\n    return tryCatalog(() =>\n      loadOptions === undefined ? catalog.loadTable(id) : catalog.loadTable(id, loadOptions),\n    );\n  }\n\n  return IcebergCatalog.of({\n    getCatalogClient: () => catalog,\n    loadConfig: () => tryCatalog(() => catalog.loadConfig()),\n\n    listNamespaces: (listOptions) => tryCatalog(() => catalog.listNamespaces(listOptions)),\n    createNamespace: (id, metadata) => tryCatalog(() => catalog.createNamespace(id, metadata)),\n    dropNamespace: (id) => tryCatalog(() => catalog.dropNamespace(id)),\n    loadNamespaceMetadata: (id) => tryCatalog(() => catalog.loadNamespaceMetadata(id)),\n    updateNamespaceProperties: (id, request) =>\n      tryCatalog(() => catalog.updateNamespaceProperties(id, request)),\n\n    listTables: (namespace, listOptions) =>\n      tryCatalog(() => catalog.listTables(namespace, listOptions)),\n    createTable: (namespace, request) => tryCatalog(() => catalog.createTable(namespace, request)),\n    createTableResult: (namespace, request) =>\n      tryCatalog(() => catalog.createTableResult(namespace, request)),\n    updateTable: (id, request) => tryCatalog(() => catalog.updateTable(id, request)),\n    commitTable: (id, request) => tryCatalog(() => catalog.commitTable(id, request)),\n    dropTable: (id, dropOptions) => tryCatalog(() => catalog.dropTable(id, dropOptions)),\n    loadTable,\n    loadTableResult: (id, loadOptions) =>\n      tryCatalog(() => catalog.loadTableResult(id, loadOptions)),\n    namespaceExists: (id) => tryCatalog(() => catalog.namespaceExists(id)),\n    tableExists: (id) => tryCatalog(() => catalog.tableExists(id)),\n    createNamespaceIfNotExists: (id, metadata) =>\n      tryCatalog(() => catalog.createNamespaceIfNotExists(id, metadata)),\n    createTableIfNotExists: (namespace, request) =>\n      tryCatalog(() => catalog.createTableIfNotExists(namespace, request)),\n    registerTable: (namespace, request) =>\n      tryCatalog(() => catalog.registerTable(namespace, request)),\n    registerTableResult: (namespace, request) =>\n      tryCatalog(() => catalog.registerTableResult(namespace, request)),\n    renameTable: (request) => tryCatalog(() => catalog.renameTable(request)),\n  });\n};\n\nconst service = Effect.service(IcebergCatalog);\n\nexport const getCatalogClient: Effect.Effect<IcebergRestCatalog, never, IcebergCatalog> =\n  Effect.map(service, (catalog) => catalog.getCatalogClient());\n\nexport const loadConfig: Effect.Effect<CatalogConfig, IcebergError, IcebergCatalog> =\n  Effect.flatMap(service, (catalog) => catalog.loadConfig());\n\nexport const listNamespaces = (\n  options?: ListNamespacesOptions,\n): Effect.Effect<ListNamespacesResult, IcebergError, IcebergCatalog> =>\n  Effect.flatMap(service, (catalog) => catalog.listNamespaces(options));\n\nexport const createNamespace = (\n  id: NamespaceIdentifier,\n  metadata?: NamespaceMetadata,\n): Effect.Effect<CreateNamespaceResponse, IcebergError, IcebergCatalog> =>\n  Effect.flatMap(service, (catalog) => catalog.createNamespace(id, metadata));\n\nexport const dropNamespace = (\n  id: NamespaceIdentifier,\n): Effect.Effect<void, IcebergError, IcebergCatalog> =>\n  Effect.flatMap(service, (catalog) => catalog.dropNamespace(id));\n\nexport const loadNamespaceMetadata = (\n  id: NamespaceIdentifier,\n): Effect.Effect<NamespaceMetadata, IcebergError, IcebergCatalog> =>\n  Effect.flatMap(service, (catalog) => catalog.loadNamespaceMetadata(id));\n\nexport const updateNamespaceProperties = (\n  id: NamespaceIdentifier,\n  request: UpdateNamespacePropertiesRequest,\n): Effect.Effect<UpdateNamespacePropertiesResponse, IcebergError, IcebergCatalog> =>\n  Effect.flatMap(service, (catalog) => catalog.updateNamespaceProperties(id, request));\n\nexport const listTables = (\n  namespace: NamespaceIdentifier,\n  options?: ListTablesOptions,\n): Effect.Effect<ListTablesResult, IcebergError, IcebergCatalog> =>\n  Effect.flatMap(service, (catalog) => catalog.listTables(namespace, options));\n\nexport const createTable = (\n  namespace: NamespaceIdentifier,\n  request: CreateTableRequest,\n): Effect.Effect<TableMetadata, IcebergError, IcebergCatalog> =>\n  Effect.flatMap(service, (catalog) => catalog.createTable(namespace, request));\n\nexport const createTableResult = (\n  namespace: NamespaceIdentifier,\n  request: CreateTableRequest,\n): Effect.Effect<LoadTableResultWithEtag, IcebergError, IcebergCatalog> =>\n  Effect.flatMap(service, (catalog) => catalog.createTableResult(namespace, request));\n\nexport const updateTable = (\n  id: TableIdentifier,\n  request: UpdateTableRequest,\n): Effect.Effect<CommitTableResponse, IcebergError, IcebergCatalog> =>\n  Effect.flatMap(service, (catalog) => catalog.updateTable(id, request));\n\nexport const commitTable = (\n  id: TableIdentifier,\n  request: CommitTableRequest,\n): Effect.Effect<CommitTableResponse, IcebergError, IcebergCatalog> =>\n  Effect.flatMap(service, (catalog) => catalog.commitTable(id, request));\n\nexport const dropTable = (\n  id: TableIdentifier,\n  options?: DropTableRequest,\n): Effect.Effect<void, IcebergError, IcebergCatalog> =>\n  Effect.flatMap(service, (catalog) => catalog.dropTable(id, options));\n\nexport function loadTable(\n  id: TableIdentifier,\n): Effect.Effect<TableMetadata, IcebergError, IcebergCatalog>;\nexport function loadTable(\n  id: TableIdentifier,\n  options: LoadTableOptions,\n): Effect.Effect<TableMetadata | null, IcebergError, IcebergCatalog>;\nexport function loadTable(id: TableIdentifier, options?: LoadTableOptions) {\n  return Effect.flatMap(service, (catalog) =>\n    options === undefined ? catalog.loadTable(id) : catalog.loadTable(id, options),\n  );\n}\n\nexport const loadTableResult = (\n  id: TableIdentifier,\n  options?: LoadTableOptions,\n): Effect.Effect<LoadTableResultWithEtag | null, IcebergError, IcebergCatalog> =>\n  Effect.flatMap(service, (catalog) => catalog.loadTableResult(id, options));\n\nexport const namespaceExists = (\n  id: NamespaceIdentifier,\n): Effect.Effect<boolean, IcebergError, IcebergCatalog> =>\n  Effect.flatMap(service, (catalog) => catalog.namespaceExists(id));\n\nexport const tableExists = (\n  id: TableIdentifier,\n): Effect.Effect<boolean, IcebergError, IcebergCatalog> =>\n  Effect.flatMap(service, (catalog) => catalog.tableExists(id));\n\nexport const createNamespaceIfNotExists = (\n  id: NamespaceIdentifier,\n  metadata?: NamespaceMetadata,\n): Effect.Effect<CreateNamespaceResponse | void, IcebergError, IcebergCatalog> =>\n  Effect.flatMap(service, (catalog) => catalog.createNamespaceIfNotExists(id, metadata));\n\nexport const createTableIfNotExists = (\n  namespace: NamespaceIdentifier,\n  request: CreateTableRequest,\n): Effect.Effect<TableMetadata, IcebergError, IcebergCatalog> =>\n  Effect.flatMap(service, (catalog) => catalog.createTableIfNotExists(namespace, request));\n\nexport const registerTable = (\n  namespace: NamespaceIdentifier,\n  request: RegisterTableRequest,\n): Effect.Effect<TableMetadata, IcebergError, IcebergCatalog> =>\n  Effect.flatMap(service, (catalog) => catalog.registerTable(namespace, request));\n\nexport const registerTableResult = (\n  namespace: NamespaceIdentifier,\n  request: RegisterTableRequest,\n): Effect.Effect<LoadTableResultWithEtag, IcebergError, IcebergCatalog> =>\n  Effect.flatMap(service, (catalog) => catalog.registerTableResult(namespace, request));\n\nexport const renameTable = (\n  request: RenameTableRequest,\n): Effect.Effect<void, IcebergError, IcebergCatalog> =>\n  Effect.flatMap(service, (catalog) => catalog.renameTable(request));\n\n/** Creates an `IcebergCatalog` layer from concrete `iceberg-js` catalog options. */\nexport const layer = (options: IcebergRestCatalogOptions): Layer.Layer<IcebergCatalog> =>\n  Layer.succeed(IcebergCatalog)(make(options));\n\n/** Creates an `IcebergCatalog` layer from Effect `Config` values. */\nexport const layerConfig = (\n  config: Config.Wrap<IcebergRestCatalogOptions>,\n): Layer.Layer<IcebergCatalog, Config.ConfigError> =>\n  Layer.effect(\n    IcebergCatalog,\n    Effect.gen(function* () {\n      const options = yield* Config.unwrap(config);\n      return make(options);\n    }),\n  );\n"],"mappings":"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"}

package/package.json

@@ -1,12 +1,49 @@
 {
   "name": "@useairfoil/effect-iceberg",
-  "version": "0.0.0",
-  "description": "",
-  "main": "index.js",
+  "version": "0.0.1",
+  "keywords": [
+    "effect",
+    "iceberg"
+  ],
+  "repository": "useairfoil/typescript-sdk",
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
   "scripts": {
+    "build": "tsdown",
+    "test": "vitest",
+    "test:ci": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@effect/vitest": "4.0.0-beta.83",
+    "@types/node": "^24.2.0",
+    "iceberg-js": "^1.0.0",
+    "tsdown": "^0.15.6",
+    "vitest": "^3.2.4"
+  },
+  "peerDependencies": {
+    "effect": "4.0.0-beta.83",
+    "iceberg-js": "^1.0.0"
   },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "packageManager": "pnpm@10.28.0"
+  "peerDependenciesMeta": {
+    "effect": {
+      "optional": false
+    },
+    "iceberg-js": {
+      "optional": false
+    }
+  }
 }

package/src/catalog.ts

@@ -0,0 +1,377 @@
+import type {
+  CatalogConfig,
+  CommitTableRequest,
+  CommitTableResponse,
+  CreateNamespaceResponse,
+  CreateTableRequest,
+  DropTableRequest,
+  IcebergRestCatalogOptions,
+  ListNamespacesOptions,
+  ListNamespacesResult,
+  ListTablesOptions,
+  ListTablesResult,
+  LoadTableOptions,
+  LoadTableResultWithEtag,
+  NamespaceIdentifier,
+  NamespaceMetadata,
+  RegisterTableRequest,
+  RenameTableRequest,
+  TableIdentifier,
+  TableMetadata,
+  UpdateNamespacePropertiesRequest,
+  UpdateNamespacePropertiesResponse,
+  UpdateTableRequest,
+} from "iceberg-js";
+
+import { Config, Context, Effect, Layer } from "effect";
+import { IcebergRestCatalog } from "iceberg-js";
+
+import type { IcebergError } from "./errors";
+
+import { mapIcebergError } from "./errors";
+
+export interface Service {
+  /**
+   * Returns the underlying `iceberg-js` catalog client.
+   *
+   * Use this for advanced cases that need direct access to the Promise-based API.
+   */
+  readonly getCatalogClient: () => IcebergRestCatalog;
+
+  /**
+   * Fetch and cache the server's catalog configuration. Calling this is optional;
+   * catalog operations trigger it lazily when a warehouse is configured.
+   */
+  readonly loadConfig: () => Effect.Effect<CatalogConfig, IcebergError>;
+
+  /** Lists all namespaces in the catalog. */
+  readonly listNamespaces: (
+    options?: ListNamespacesOptions,
+  ) => Effect.Effect<ListNamespacesResult, IcebergError>;
+
+  /** Creates a new namespace in the catalog. */
+  readonly createNamespace: (
+    id: NamespaceIdentifier,
+    metadata?: NamespaceMetadata,
+  ) => Effect.Effect<CreateNamespaceResponse, IcebergError>;
+
+  /**
+   * Drops a namespace from the catalog.
+   *
+   * The namespace must be empty before it can be dropped.
+   */
+  readonly dropNamespace: (id: NamespaceIdentifier) => Effect.Effect<void, IcebergError>;
+
+  /** Loads metadata for a namespace. */
+  readonly loadNamespaceMetadata: (
+    id: NamespaceIdentifier,
+  ) => Effect.Effect<NamespaceMetadata, IcebergError>;
+
+  /** Sets or removes properties on a namespace. */
+  readonly updateNamespaceProperties: (
+    id: NamespaceIdentifier,
+    request: UpdateNamespacePropertiesRequest,
+  ) => Effect.Effect<UpdateNamespacePropertiesResponse, IcebergError>;
+
+  /** Lists tables in a namespace. */
+  readonly listTables: (
+    namespace: NamespaceIdentifier,
+    options?: ListTablesOptions,
+  ) => Effect.Effect<ListTablesResult, IcebergError>;
+
+  /** Creates a new table in the catalog. */
+  readonly createTable: (
+    namespace: NamespaceIdentifier,
+    request: CreateTableRequest,
+  ) => Effect.Effect<TableMetadata, IcebergError>;
+
+  /**
+   * Creates a table and returns the full spec-aligned `LoadTableResult`, including
+   * server config, storage credentials, and the response ETag.
+   */
+  readonly createTableResult: (
+    namespace: NamespaceIdentifier,
+    request: CreateTableRequest,
+  ) => Effect.Effect<LoadTableResultWithEtag, IcebergError>;
+
+  /** Commits updates to a table using the spec-aligned `{ requirements, updates }` shape. */
+  readonly updateTable: (
+    id: TableIdentifier,
+    request: UpdateTableRequest,
+  ) => Effect.Effect<CommitTableResponse, IcebergError>;
+
+  /** Spec-aligned alias for `updateTable`. */
+  readonly commitTable: (
+    id: TableIdentifier,
+    request: CommitTableRequest,
+  ) => Effect.Effect<CommitTableResponse, IcebergError>;
+
+  /** Drops a table from the catalog. */
+  readonly dropTable: (
+    id: TableIdentifier,
+    options?: DropTableRequest,
+  ) => Effect.Effect<void, IcebergError>;
+
+  /**
+   * Loads metadata for a table.
+   *
+   * Pass `ifNoneMatch` in options to perform a conditional GET. If the server
+   * returns 304 Not Modified, the result is `null`.
+   */
+  readonly loadTable: {
+    (id: TableIdentifier): Effect.Effect<TableMetadata, IcebergError>;
+    (
+      id: TableIdentifier,
+      options: LoadTableOptions,
+    ): Effect.Effect<TableMetadata | null, IcebergError>;
+  };
+
+  /**
+   * Loads the full spec-aligned `LoadTableResult`, including server config,
+   * storage credentials, and the response ETag. Returns `null` on 304.
+   */
+  readonly loadTableResult: (
+    id: TableIdentifier,
+    options?: LoadTableOptions,
+  ) => Effect.Effect<LoadTableResultWithEtag | null, IcebergError>;
+
+  /** Checks if a namespace exists in the catalog. */
+  readonly namespaceExists: (id: NamespaceIdentifier) => Effect.Effect<boolean, IcebergError>;
+
+  /** Checks if a table exists in the catalog. */
+  readonly tableExists: (id: TableIdentifier) => Effect.Effect<boolean, IcebergError>;
+
+  /** Creates a namespace if it does not exist. */
+  readonly createNamespaceIfNotExists: (
+    id: NamespaceIdentifier,
+    metadata?: NamespaceMetadata,
+  ) => Effect.Effect<CreateNamespaceResponse | void, IcebergError>;
+
+  /** Creates a table if it does not exist. */
+  readonly createTableIfNotExists: (
+    namespace: NamespaceIdentifier,
+    request: CreateTableRequest,
+  ) => Effect.Effect<TableMetadata, IcebergError>;
+
+  /** Registers an existing metadata file as a table in the given namespace. */
+  readonly registerTable: (
+    namespace: NamespaceIdentifier,
+    request: RegisterTableRequest,
+  ) => Effect.Effect<TableMetadata, IcebergError>;
+
+  /** Returns the full spec-aligned `LoadTableResult` for `registerTable`. */
+  readonly registerTableResult: (
+    namespace: NamespaceIdentifier,
+    request: RegisterTableRequest,
+  ) => Effect.Effect<LoadTableResultWithEtag, IcebergError>;
+
+  /** Renames a table. Servers may or may not support cross-namespace renames. */
+  readonly renameTable: (request: RenameTableRequest) => Effect.Effect<void, IcebergError>;
+}
+
+/** Service for the Effect wrapper around `iceberg-js`'s `IcebergRestCatalog`. */
+export class IcebergCatalog extends Context.Service<IcebergCatalog, Service>()(
+  "@useairfoil/effect-iceberg/IcebergCatalog",
+) {}
+
+const tryCatalog = <A>(evaluate: () => Promise<A>): Effect.Effect<A, IcebergError> =>
+  Effect.tryPromise({
+    try: evaluate,
+    catch: mapIcebergError,
+  });
+
+/** Creates an `IcebergCatalog` service from `iceberg-js` catalog options. */
+export const make = (options: IcebergRestCatalogOptions): Service => {
+  const catalog = new IcebergRestCatalog(options);
+
+  function loadTable(id: TableIdentifier): Effect.Effect<TableMetadata, IcebergError>;
+  function loadTable(
+    id: TableIdentifier,
+    loadOptions: LoadTableOptions,
+  ): Effect.Effect<TableMetadata | null, IcebergError>;
+  function loadTable(id: TableIdentifier, loadOptions?: LoadTableOptions) {
+    return tryCatalog(() =>
+      loadOptions === undefined ? catalog.loadTable(id) : catalog.loadTable(id, loadOptions),
+    );
+  }
+
+  return IcebergCatalog.of({
+    getCatalogClient: () => catalog,
+    loadConfig: () => tryCatalog(() => catalog.loadConfig()),
+
+    listNamespaces: (listOptions) => tryCatalog(() => catalog.listNamespaces(listOptions)),
+    createNamespace: (id, metadata) => tryCatalog(() => catalog.createNamespace(id, metadata)),
+    dropNamespace: (id) => tryCatalog(() => catalog.dropNamespace(id)),
+    loadNamespaceMetadata: (id) => tryCatalog(() => catalog.loadNamespaceMetadata(id)),
+    updateNamespaceProperties: (id, request) =>
+      tryCatalog(() => catalog.updateNamespaceProperties(id, request)),
+
+    listTables: (namespace, listOptions) =>
+      tryCatalog(() => catalog.listTables(namespace, listOptions)),
+    createTable: (namespace, request) => tryCatalog(() => catalog.createTable(namespace, request)),
+    createTableResult: (namespace, request) =>
+      tryCatalog(() => catalog.createTableResult(namespace, request)),
+    updateTable: (id, request) => tryCatalog(() => catalog.updateTable(id, request)),
+    commitTable: (id, request) => tryCatalog(() => catalog.commitTable(id, request)),
+    dropTable: (id, dropOptions) => tryCatalog(() => catalog.dropTable(id, dropOptions)),
+    loadTable,
+    loadTableResult: (id, loadOptions) =>
+      tryCatalog(() => catalog.loadTableResult(id, loadOptions)),
+    namespaceExists: (id) => tryCatalog(() => catalog.namespaceExists(id)),
+    tableExists: (id) => tryCatalog(() => catalog.tableExists(id)),
+    createNamespaceIfNotExists: (id, metadata) =>
+      tryCatalog(() => catalog.createNamespaceIfNotExists(id, metadata)),
+    createTableIfNotExists: (namespace, request) =>
+      tryCatalog(() => catalog.createTableIfNotExists(namespace, request)),
+    registerTable: (namespace, request) =>
+      tryCatalog(() => catalog.registerTable(namespace, request)),
+    registerTableResult: (namespace, request) =>
+      tryCatalog(() => catalog.registerTableResult(namespace, request)),
+    renameTable: (request) => tryCatalog(() => catalog.renameTable(request)),
+  });
+};
+
+const service = Effect.service(IcebergCatalog);
+
+export const getCatalogClient: Effect.Effect<IcebergRestCatalog, never, IcebergCatalog> =
+  Effect.map(service, (catalog) => catalog.getCatalogClient());
+
+export const loadConfig: Effect.Effect<CatalogConfig, IcebergError, IcebergCatalog> =
+  Effect.flatMap(service, (catalog) => catalog.loadConfig());
+
+export const listNamespaces = (
+  options?: ListNamespacesOptions,
+): Effect.Effect<ListNamespacesResult, IcebergError, IcebergCatalog> =>
+  Effect.flatMap(service, (catalog) => catalog.listNamespaces(options));
+
+export const createNamespace = (
+  id: NamespaceIdentifier,
+  metadata?: NamespaceMetadata,
+): Effect.Effect<CreateNamespaceResponse, IcebergError, IcebergCatalog> =>
+  Effect.flatMap(service, (catalog) => catalog.createNamespace(id, metadata));
+
+export const dropNamespace = (
+  id: NamespaceIdentifier,
+): Effect.Effect<void, IcebergError, IcebergCatalog> =>
+  Effect.flatMap(service, (catalog) => catalog.dropNamespace(id));
+
+export const loadNamespaceMetadata = (
+  id: NamespaceIdentifier,
+): Effect.Effect<NamespaceMetadata, IcebergError, IcebergCatalog> =>
+  Effect.flatMap(service, (catalog) => catalog.loadNamespaceMetadata(id));
+
+export const updateNamespaceProperties = (
+  id: NamespaceIdentifier,
+  request: UpdateNamespacePropertiesRequest,
+): Effect.Effect<UpdateNamespacePropertiesResponse, IcebergError, IcebergCatalog> =>
+  Effect.flatMap(service, (catalog) => catalog.updateNamespaceProperties(id, request));
+
+export const listTables = (
+  namespace: NamespaceIdentifier,
+  options?: ListTablesOptions,
+): Effect.Effect<ListTablesResult, IcebergError, IcebergCatalog> =>
+  Effect.flatMap(service, (catalog) => catalog.listTables(namespace, options));
+
+export const createTable = (
+  namespace: NamespaceIdentifier,
+  request: CreateTableRequest,
+): Effect.Effect<TableMetadata, IcebergError, IcebergCatalog> =>
+  Effect.flatMap(service, (catalog) => catalog.createTable(namespace, request));
+
+export const createTableResult = (
+  namespace: NamespaceIdentifier,
+  request: CreateTableRequest,
+): Effect.Effect<LoadTableResultWithEtag, IcebergError, IcebergCatalog> =>
+  Effect.flatMap(service, (catalog) => catalog.createTableResult(namespace, request));
+
+export const updateTable = (
+  id: TableIdentifier,
+  request: UpdateTableRequest,
+): Effect.Effect<CommitTableResponse, IcebergError, IcebergCatalog> =>
+  Effect.flatMap(service, (catalog) => catalog.updateTable(id, request));
+
+export const commitTable = (
+  id: TableIdentifier,
+  request: CommitTableRequest,
+): Effect.Effect<CommitTableResponse, IcebergError, IcebergCatalog> =>
+  Effect.flatMap(service, (catalog) => catalog.commitTable(id, request));
+
+export const dropTable = (
+  id: TableIdentifier,
+  options?: DropTableRequest,
+): Effect.Effect<void, IcebergError, IcebergCatalog> =>
+  Effect.flatMap(service, (catalog) => catalog.dropTable(id, options));
+
+export function loadTable(
+  id: TableIdentifier,
+): Effect.Effect<TableMetadata, IcebergError, IcebergCatalog>;
+export function loadTable(
+  id: TableIdentifier,
+  options: LoadTableOptions,
+): Effect.Effect<TableMetadata | null, IcebergError, IcebergCatalog>;
+export function loadTable(id: TableIdentifier, options?: LoadTableOptions) {
+  return Effect.flatMap(service, (catalog) =>
+    options === undefined ? catalog.loadTable(id) : catalog.loadTable(id, options),
+  );
+}
+
+export const loadTableResult = (
+  id: TableIdentifier,
+  options?: LoadTableOptions,
+): Effect.Effect<LoadTableResultWithEtag | null, IcebergError, IcebergCatalog> =>
+  Effect.flatMap(service, (catalog) => catalog.loadTableResult(id, options));
+
+export const namespaceExists = (
+  id: NamespaceIdentifier,
+): Effect.Effect<boolean, IcebergError, IcebergCatalog> =>
+  Effect.flatMap(service, (catalog) => catalog.namespaceExists(id));
+
+export const tableExists = (
+  id: TableIdentifier,
+): Effect.Effect<boolean, IcebergError, IcebergCatalog> =>
+  Effect.flatMap(service, (catalog) => catalog.tableExists(id));
+
+export const createNamespaceIfNotExists = (
+  id: NamespaceIdentifier,
+  metadata?: NamespaceMetadata,
+): Effect.Effect<CreateNamespaceResponse | void, IcebergError, IcebergCatalog> =>
+  Effect.flatMap(service, (catalog) => catalog.createNamespaceIfNotExists(id, metadata));
+
+export const createTableIfNotExists = (
+  namespace: NamespaceIdentifier,
+  request: CreateTableRequest,
+): Effect.Effect<TableMetadata, IcebergError, IcebergCatalog> =>
+  Effect.flatMap(service, (catalog) => catalog.createTableIfNotExists(namespace, request));
+
+export const registerTable = (
+  namespace: NamespaceIdentifier,
+  request: RegisterTableRequest,
+): Effect.Effect<TableMetadata, IcebergError, IcebergCatalog> =>
+  Effect.flatMap(service, (catalog) => catalog.registerTable(namespace, request));
+
+export const registerTableResult = (
+  namespace: NamespaceIdentifier,
+  request: RegisterTableRequest,
+): Effect.Effect<LoadTableResultWithEtag, IcebergError, IcebergCatalog> =>
+  Effect.flatMap(service, (catalog) => catalog.registerTableResult(namespace, request));
+
+export const renameTable = (
+  request: RenameTableRequest,
+): Effect.Effect<void, IcebergError, IcebergCatalog> =>
+  Effect.flatMap(service, (catalog) => catalog.renameTable(request));
+
+/** Creates an `IcebergCatalog` layer from concrete `iceberg-js` catalog options. */
+export const layer = (options: IcebergRestCatalogOptions): Layer.Layer<IcebergCatalog> =>
+  Layer.succeed(IcebergCatalog)(make(options));
+
+/** Creates an `IcebergCatalog` layer from Effect `Config` values. */
+export const layerConfig = (
+  config: Config.Wrap<IcebergRestCatalogOptions>,
+): Layer.Layer<IcebergCatalog, Config.ConfigError> =>
+  Layer.effect(
+    IcebergCatalog,
+    Effect.gen(function* () {
+      const options = yield* Config.unwrap(config);
+      return make(options);
+    }),
+  );

package/src/errors.ts

@@ -0,0 +1,33 @@
+import { Data } from "effect";
+import { IcebergError as IcebergJsError } from "iceberg-js";
+
+/** Error type used by the Effect wrapper around `iceberg-js`. */
+export class IcebergError extends Data.TaggedError("IcebergError")<{
+  readonly message: string;
+  readonly status?: number;
+  readonly icebergType?: string;
+  readonly icebergCode?: number;
+  readonly details?: unknown;
+  readonly isCommitStateUnknown?: boolean;
+  readonly cause?: unknown;
+}> {}
+
+/** Maps errors thrown by `iceberg-js` into `IcebergError`. */
+export const mapIcebergError = (error: unknown): IcebergError => {
+  if (error instanceof IcebergJsError) {
+    return new IcebergError({
+      message: error.message,
+      status: error.status,
+      icebergType: error.icebergType,
+      icebergCode: error.icebergCode,
+      details: error.details,
+      isCommitStateUnknown: error.isCommitStateUnknown,
+      cause: error,
+    });
+  }
+
+  return new IcebergError({
+    message: error instanceof Error ? error.message : String(error),
+    cause: error,
+  });
+};

package/src/index.ts

@@ -0,0 +1,2 @@
+export * as IcebergCatalog from "./catalog";
+export * as IcebergError from "./errors";