alchemy 0.69.1 → 0.70.1

package/src/clickhouse/api-key.ts

@@ -0,0 +1,136 @@
+import type { Context } from "../context.ts";
+import { Resource } from "../resource.ts";
+import { secret, type Secret } from "../secret.ts";
+import { diff } from "../util/diff.ts";
+import { createClickhouseApi } from "./api.ts";
+import type { ApiKey as ApiApiKey, Organization } from "./api/types.gen.ts";
+
+export interface ApiKeyProps {
+  keyId?: string | Secret<string>;
+  secret?: string | Secret<string>;
+  organization: string | Organization;
+  name?: ApiApiKey["name"];
+  expireAt?: ApiApiKey["expireAt"];
+  roles?: ApiApiKey["roles"];
+  ipAccessList?: ApiApiKey["ipAccessList"];
+  state?: ApiApiKey["state"];
+}
+
+export interface ApiKey {
+  organizationId: string;
+  name: string;
+  clickhouseId: NonNullable<ApiApiKey["id"]>;
+  keyId: string;
+  secret: Secret<string>;
+  state: NonNullable<ApiApiKey["state"]>;
+  roles: NonNullable<ApiApiKey["roles"]>;
+  keySuffix: NonNullable<ApiApiKey["keySuffix"]>;
+  createdAt: NonNullable<ApiApiKey["createdAt"]>;
+  expireAt?: ApiApiKey["expireAt"];
+  usedAt?: ApiApiKey["usedAt"];
+  ipAccessList: ApiApiKey["ipAccessList"];
+}
+
+export const ApiKey = Resource(
+  "clickhouse::ApiKey",
+  async function (
+    this: Context<ApiKey>,
+    id: string,
+    props: ApiKeyProps,
+  ): Promise<ApiKey> {
+    const api = createClickhouseApi({
+      keyId: props.keyId,
+      secret: props.secret,
+    });
+
+    const name =
+      props.name ?? this.output?.name ?? this.scope.createPhysicalName(id);
+    const state = props.state ?? this.output?.state ?? "enabled";
+
+    const organizationId =
+      typeof props.organization === "string"
+        ? props.organization
+        : props.organization.id!;
+
+    if (this.phase === "delete") {
+      await api.deleteKey({
+        path: {
+          organizationId: organizationId,
+          keyId: this.output.clickhouseId,
+        },
+      });
+      return this.destroy();
+    }
+    if (this.phase === "update") {
+      if (
+        diff(
+          { ...props, name },
+          { ...this.output, organization: props.organization },
+        ).some(
+          (prop) =>
+            prop !== "name" &&
+            prop !== "roles" &&
+            prop !== "ipAccessList" &&
+            prop !== "expireAt" &&
+            prop !== "state",
+        )
+      ) {
+        return this.replace();
+      }
+      const updatedKey = await api.updateKey({
+        path: {
+          organizationId: organizationId!,
+          keyId: this.output.clickhouseId!,
+        },
+        body: {
+          name,
+          roles: props.roles,
+          ipAccessList: props.ipAccessList,
+          expireAt: props.expireAt,
+          state,
+        },
+      });
+
+      return {
+        ...this.output,
+        ...updatedKey,
+        name,
+      };
+    }
+
+    const key = (
+      await api.createKey({
+        path: {
+          organizationId: organizationId!,
+        },
+        body: {
+          name,
+          expireAt: props.expireAt ?? "2999-12-31T00:00:00.000Z",
+          ipAccessList: props.ipAccessList ?? [
+            {
+              description: "Anywhere",
+              source: "0.0.0.0/0",
+            },
+          ],
+          roles: props.roles ?? ["admin"],
+          state,
+        },
+      })
+    ).data.result!;
+
+    return {
+      organizationId: organizationId,
+      name: key!.key!.name!,
+      clickhouseId: key!.key!.id!,
+      state: key!.key!.state!,
+      roles: key!.key!.roles!,
+      keySuffix: key!.key!.keySuffix!,
+      createdAt: key!.key!.createdAt!,
+      expireAt: key!.key!.expireAt!,
+      usedAt: key!.key!.usedAt,
+      ipAccessList: key!.key!.ipAccessList!,
+      keyId: key!.keyId!,
+      secret: secret(key.keySecret),
+    };
+  },
+);

package/src/clickhouse/api.ts

@@ -0,0 +1,84 @@
+import type { Secret } from "../secret.ts";
+import { createClient } from "../util/api/client/client.gen.ts";
+import type { ClientOptions } from "../util/api/client/types.gen.ts";
+import { createConfig } from "../util/api/client/utils.gen.ts";
+import { ClickhouseClient } from "./api/sdk.gen.ts";
+
+/**
+ * Options for Neon API requests
+ */
+export interface ClickhouseApiOptions {
+  /**
+   * The key ID for the Clickhouse API
+   */
+  keyId?: string | Secret<string>;
+
+  /**
+   * The secret for the Clickhouse API
+   */
+  secret?: string | Secret<string>;
+}
+
+export class ClickhouseError extends Error {
+  status: number;
+  method: string;
+  url: string;
+  code: string;
+
+  constructor(props: {
+    error: {
+      status?: number;
+      error?: string;
+    };
+    request: Request;
+    response: Response;
+  }) {
+    const { status, error } = props.error;
+    super(
+      `A request to the Clickhouse API failed (${props.response.status}): ${error}`,
+    );
+    this.status = props.response.status;
+    this.method = props.request.method;
+    this.url = props.request.url;
+    this.code = status?.toString() ?? "";
+    Object.assign(this, props.error);
+  }
+}
+
+/**
+ * Create a ClickhouseApi instance with environment variable fallback
+ * @param options API options
+ * @returns ClickhouseApi instance
+ */
+export function createClickhouseApi(
+  options: Partial<ClickhouseApiOptions> = {},
+): ClickhouseClient {
+  const keyId = options?.keyId ?? process.env.CLICKHOUSE_KEY_ID;
+  const secret = options?.secret ?? process.env.CLICKHOUSE_KEY_SECRET;
+
+  const client = createClient(
+    createConfig<ClientOptions>({
+      baseUrl: "https://api.clickhouse.cloud",
+      throwOnError: true,
+      headers: {
+        Authorization: `Basic ${btoa(`${keyId}:${secret}`)}`,
+      },
+    }),
+  );
+  client.interceptors.error.use((error, response, request, options) => {
+    if (options.throwOnError !== false) {
+      throw new ClickhouseError({
+        error: error as {
+          status?: number;
+          error?: string;
+        },
+        request,
+        response,
+      });
+    }
+    return error;
+  });
+  return new ClickhouseClient({
+    client,
+  });
+}

package/src/clickhouse/index.ts

@@ -0,0 +1,3 @@
+export * from "./api-key.ts";
+export * from "./organization.ts";
+export * from "./service.ts";

package/src/clickhouse/organization.ts

@@ -0,0 +1,31 @@
+import type { Secret } from "../secret.ts";
+import { createClickhouseApi } from "./api.ts";
+
+/**
+ * Get an organization by name.
+ *
+ * @example
+ * const organization = await getOrganizationByName("Alchemy's Organization");
+ *
+ * @param name The name of the organization to get.
+ * @param options The api credentials to use.
+ * @returns The organization.
+ */
+export async function OrganizationRef(
+  name: string,
+  options?: {
+    keyId?: string | Secret<string>;
+    secret?: string | Secret<string>;
+  },
+) {
+  const api = createClickhouseApi(options);
+
+  const organizations = await api.listAvailableOrganizations();
+  const organization = organizations.data.result?.find(
+    (organization) => organization.name === name,
+  );
+  if (!organization) {
+    throw new Error(`Organization ${name} not found`);
+  }
+  return organization;
+}