alchemy 0.16.6 → 0.16.8

package/src/vercel/api.ts

@@ -0,0 +1,163 @@
+import { alchemy } from "../alchemy.js";
+import type { Secret } from "../secret.js";
+
+/**
+ * Options for Vercel API requests
+ */
+export interface VercelApiOptions {
+  /**
+   * Base URL for API
+   */
+  baseUrl: string;
+
+  /**
+   * API access token to use (overrides environment variable)
+   */
+  accessToken?: Secret;
+}
+
+/**
+ * Creates a VercelApi instance with automatic token validation
+ *
+ * @param options API options
+ * @returns Promise resolving to a VercelApi instance
+ */
+export async function createVercelApi(
+  options: VercelApiOptions,
+): Promise<VercelApi> {
+  const {
+    accessToken = await alchemy.secret.env.VERCEL_ACCESS_TOKEN,
+    baseUrl,
+  } = options;
+
+  return new VercelApi({
+    baseUrl,
+    accessToken,
+  });
+}
+
+/**
+ * Vercel API client using raw fetch
+ */
+export class VercelApi {
+  /** Base URL for API */
+  readonly baseUrl: string;
+
+  /** API access token */
+  readonly accessToken: Secret;
+
+  /**
+   * Create a new API client
+   * Use createVercelApi factory function instead of direct constructor
+   * for automatic token validation.
+   *
+   * @param options API options
+   */
+  constructor(options: VercelApiOptions & { accessToken: Secret }) {
+    this.baseUrl = options.baseUrl;
+    this.accessToken = options.accessToken;
+  }
+
+  /**
+   * Make a request to the API
+   *
+   * @param path API path (without base URL)
+   * @param init Fetch init options
+   * @returns Raw Response object from fetch
+   */
+  async fetch(path: string, init: RequestInit = {}): Promise<Response> {
+    // Set up authentication headers
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.accessToken.unencrypted}`,
+    };
+
+    // Add headers from init if provided
+    if (init.headers) {
+      const initHeaders = init.headers as Record<string, string>;
+      Object.keys(initHeaders).forEach((key) => {
+        headers[key] = initHeaders[key];
+      });
+    }
+
+    // For FormData, remove Content-Type
+    if (init.body instanceof FormData) {
+      delete headers["Content-Type"];
+    }
+
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      ...init,
+      headers,
+    });
+
+    if (!response.ok) {
+      let error = new Error(`API error: ${response.statusText}`, {
+        cause: response,
+      });
+
+      try {
+        error = Object.assign(
+          new Error(response.statusText, { cause: response }),
+          ((await response.json()) as { error: Error })?.error,
+        );
+      } finally {
+        throw error;
+      }
+    }
+
+    return response;
+  }
+
+  /**
+   * Helper for GET requests
+   */
+  async get(path: string, init: RequestInit = {}): Promise<Response> {
+    return this.fetch(path, { ...init, method: "GET" });
+  }
+
+  /**
+   * Helper for POST requests
+   */
+  async post(
+    path: string,
+    body: any,
+    init: RequestInit = {},
+  ): Promise<Response> {
+    const requestBody = body instanceof FormData ? body : JSON.stringify(body);
+    return this.fetch(path, { ...init, method: "POST", body: requestBody });
+  }
+
+  /**
+   * Helper for PUT requests
+   */
+  async put(
+    path: string,
+    body: any,
+    init: RequestInit = {},
+  ): Promise<Response> {
+    const requestBody = body instanceof FormData ? body : JSON.stringify(body);
+    return this.fetch(path, { ...init, method: "PUT", body: requestBody });
+  }
+
+  /**
+   * Helper for PATCH requests
+   */
+  async patch(
+    path: string,
+    body: any,
+    init: RequestInit = {},
+  ): Promise<Response> {
+    return this.fetch(path, {
+      ...init,
+      method: "PATCH",
+      body: JSON.stringify(body),
+    });
+  }
+
+  /**
+   * Helper for DELETE requests
+   */
+  async delete(path: string, init: RequestInit = {}): Promise<Response> {
+    return this.fetch(path, { ...init, method: "DELETE" });
+  }
+}

package/src/vercel/index.ts

@@ -0,0 +1,3 @@
+export * from "./api.js";
+export * from "./project-domain.js";
+export * from "./project.js";

package/src/vercel/project-domain.ts

@@ -0,0 +1,172 @@
+import type { Context } from "../context.js";
+import { Resource } from "../resource.js";
+import type { Secret } from "../secret.js";
+import { createVercelApi } from "./api.js";
+
+/**
+ * Properties for creating or updating a ProjectDomain
+ */
+export interface ProjectDomainProps {
+  /**
+   * The domain name to add to the project
+   */
+  name: string;
+
+  /**
+   * The unique project identifier or the project name
+   */
+  project: string;
+
+  /**
+   * The Git branch to link the domain to
+   */
+  gitBranch?: string;
+
+  /**
+   * The unique custom environment identifier within the project
+   */
+  customEnvironment?: string;
+
+  /**
+   * The redirect target for the domain
+   */
+  redirect?: string;
+
+  /**
+   * The redirect status code
+   */
+  redirectStatusCode?: 301 | 302 | 307 | 308;
+}
+
+/**
+ * Output returned after ProjectDomain creation/update
+ */
+export interface ProjectDomain
+  extends Resource<"vercel::ProjectDomain">,
+    ProjectDomainProps {
+  apexName: string;
+
+  /**
+   * `true` if the domain is verified for use with the project. If `false` it will not be used as an alias on this project until the challenge in `verification` is completed.
+   */
+  verified: boolean;
+
+  /**
+   * The time at which the domain was created
+   */
+  createdAt: number;
+
+  /**
+   * The time at which the domain was last updated
+   */
+  updatedAt: number;
+
+  /**
+   * A list of verification challenges, one of which must be completed to verify the domain for use on the project. After the challenge is complete `POST /projects/:idOrName/domains/:domain/verify` to verify the domain.
+   *
+   * Possible challenges:
+   *   - If `verification.type = TXT` the `verification.domain` will be checked for a TXT record matching `verification.value`.
+   */
+  verification?: {
+    /**
+     * The type of verification
+     */
+    type: string;
+
+    /**
+     * The domain being verified
+     */
+    domain: string;
+
+    /**
+     * The verification value
+     */
+    value: string;
+
+    /**
+     * The reason for verification
+     */
+    reason: string;
+  }[];
+}
+
+/**
+ * Add and manage domains for Vercel projects.
+ *
+ * @example
+ * // Minimal
+ * const domain = await ProjectDomain("my-app.com", {
+ *   name: "my-app.com",
+ *   project: "prj_123",
+ * });
+ *
+ * @example
+ * // With accessToken
+ * const domain = await ProjectDomain("my-app.com", {
+ *   accessToken: alchemy.secret(process.env.VERCEL_ACCESS_TOKEN),
+ *   name: "my-app.com",
+ *   project: "prj_123",
+ * });
+ *
+ * @example
+ * // With redirect
+ * const domain = await ProjectDomain("my-app.com", {
+ *   name: "my-app.com",
+ *   project: "prj_123",
+ *   gitBranch: "main",
+ *   redirect: "https://example.com",
+ *   redirectStatusCode: 301,
+ * });
+ */
+export const ProjectDomain = Resource(
+  "vercel::ProjectDomain",
+  async function (
+    this: Context<ProjectDomain>,
+    id: string,
+    { accessToken, ...props }: ProjectDomainProps & { accessToken?: Secret },
+  ): Promise<ProjectDomain> {
+    switch (this.phase) {
+      case "create": {
+        const api = await createVercelApi({
+          baseUrl: "https://api.vercel.com/v10",
+          accessToken,
+        });
+        const domain = (await api
+          .post(`/projects/${props.project}/domains`, props)
+          .then((res) => res.json())) as ProjectDomain;
+
+        return this.create({ ...props, ...domain });
+      }
+
+      case "update": {
+        const { gitBranch, redirect, redirectStatusCode } = props;
+
+        const api = await createVercelApi({
+          baseUrl: "https://api.vercel.com/v9",
+          accessToken,
+        });
+        const domain = (await api
+          .patch(`/projects/${props.project}/domains/${this.output.name}`, {
+            gitBranch,
+            redirect,
+            redirectStatusCode,
+          })
+          .then((res) => res.json())) as ProjectDomain;
+
+        return this.create({ ...props, ...domain });
+      }
+
+      case "delete": {
+        const api = await createVercelApi({
+          baseUrl: "https://api.vercel.com/v9",
+          accessToken,
+        });
+        await api.delete(
+          `/projects/${props.project}/domains/${this.output.name}`,
+        );
+
+        return this.destroy();
+      }
+    }
+  },
+);