alchemy 0.16.5 → 0.16.6

package/src/sentry/client-key.ts

@@ -0,0 +1,295 @@
+import type { Context } from "../context.js";
+import { Resource } from "../resource.js";
+import type { Secret } from "../secret.js";
+import { SentryApi } from "./api.js";
+
+/**
+ * Properties for creating or updating a ClientKey
+ */
+export interface ClientKeyProps {
+  /**
+   * The name of the key
+   */
+  name?: string;
+
+  /**
+   * Rate limit configuration
+   */
+  rateLimit?: {
+    /**
+     * Time window in seconds
+     */
+    window: number;
+
+    /**
+     * Maximum number of events allowed in the window
+     */
+    count: number;
+  };
+
+  /**
+   * The use case for the key
+   */
+  useCase?: "user" | "profiling" | "escalating_issues" | "tempest" | "demo";
+
+  /**
+   * The project slug that owns the key
+   */
+  project: string;
+
+  /**
+   * The organization ID or slug that owns the key
+   */
+  organization: string;
+
+  /**
+   * Auth token to use (overrides environment variable)
+   */
+  authToken?: Secret;
+
+  /**
+   * Whether to adopt an existing key with the same name if it exists
+   * If true and a key with the same name exists, it will be adopted rather than creating a new one
+   *
+   * @default false
+   */
+  adopt?: boolean;
+}
+
+/**
+ * Output returned after ClientKey creation/update
+ */
+export interface ClientKey
+  extends Resource<"sentry::ClientKey">,
+    ClientKeyProps {
+  /**
+   * The ID of the key
+   */
+  id: string;
+
+  /**
+   * The label of the key
+   */
+  label: string;
+
+  /**
+   * The public key
+   */
+  public: string;
+
+  /**
+   * The secret key
+   */
+  secret: string;
+
+  /**
+   * The project ID
+   */
+  projectId: number;
+
+  /**
+   * Whether the key is active
+   */
+  isActive: boolean;
+
+  /**
+   * DSN configuration
+   */
+  dsn: {
+    secret: string;
+    public: string;
+    csp: string;
+    security: string;
+    minidump: string;
+    nel: string;
+    unreal: string;
+    cdn: string;
+    crons: string;
+  };
+
+  /**
+   * Browser SDK version
+   */
+  browserSdkVersion: string;
+
+  /**
+   * Browser SDK choices
+   */
+  browserSdk: {
+    choices: Array<[string, string]>;
+  };
+
+  /**
+   * Time at which the key was created
+   */
+  dateCreated: string;
+
+  /**
+   * Dynamic SDK loader options
+   */
+  dynamicSdkLoaderOptions: {
+    hasReplay: boolean;
+    hasPerformance: boolean;
+    hasDebug: boolean;
+  };
+}
+
+/**
+ * Create and manage Sentry client keys
+ *
+ * @example
+ * // Create a basic Sentry client key:
+ * const key = await ClientKey("my-key", {
+ *   name: "My Key",
+ *   project: "my-project",
+ *   organization: "my-org"
+ * });
+ *
+ * @example
+ * // Create a client key with rate limiting:
+ * const key = await ClientKey("rate-limited-key", {
+ *   name: "Rate Limited Key",
+ *   project: "my-project",
+ *   organization: "my-org",
+ *   rateLimit: {
+ *     window: 3600, // 1 hour
+ *     count: 1000   // 1000 events per hour
+ *   }
+ * });
+ *
+ * @example
+ * // Create a client key for a specific use case:
+ * const key = await ClientKey("profiling-key", {
+ *   name: "Profiling Key",
+ *   project: "my-project",
+ *   organization: "my-org",
+ *   useCase: "profiling"
+ * });
+ *
+ * @example
+ * // Create or adopt an existing key with the same name:
+ * const key = await ClientKey("existing-key", {
+ *   name: "Existing Key",
+ *   project: "my-project",
+ *   organization: "my-org",
+ *   adopt: true
+ * });
+ */
+export const ClientKey = Resource(
+  "sentry::ClientKey",
+  async function (
+    this: Context<ClientKey>,
+    id: string,
+    props: ClientKeyProps,
+  ): Promise<ClientKey> {
+    const api = new SentryApi({ authToken: props.authToken });
+
+    if (this.phase === "delete") {
+      try {
+        if (this.output?.id) {
+          const response = await api.delete(
+            `/projects/${props.organization}/${props.project}/keys/${this.output.id}/`,
+          );
+          if (!response.ok && response.status !== 404) {
+            console.error("Error deleting client key:", response.statusText);
+          }
+        }
+      } catch (error) {
+        console.error("Error deleting client key:", error);
+      }
+      return this.destroy();
+    } else {
+      try {
+        let response;
+
+        if (this.phase === "update" && this.output?.id) {
+          response = await api.put(
+            `/projects/${props.organization}/${props.project}/keys/${this.output.id}/`,
+            props,
+          );
+        } else {
+          try {
+            response = await api.post(
+              `/projects/${props.organization}/${props.project}/keys/`,
+              props,
+            );
+          } catch (error) {
+            // Check if this is a "key already exists" error and adopt is enabled
+            if (
+              props.adopt &&
+              error instanceof Error &&
+              error.message.includes("already exists") &&
+              props.name
+            ) {
+              console.log(
+                `Client key '${props.name}' already exists, adopting it`,
+              );
+              // Find the existing key by name
+              const existingKey = await findClientKeyByName(
+                api,
+                props.organization,
+                props.project,
+                props.name,
+              );
+              if (!existingKey) {
+                throw new Error(
+                  `Failed to find existing client key '${props.name}' for adoption`,
+                );
+              }
+              response = await api.get(
+                `/projects/${props.organization}/${props.project}/keys/${existingKey.id}/`,
+              );
+            } else {
+              throw error;
+            }
+          }
+        }
+
+        if (!response.ok) {
+          throw new Error(`API error: ${response.statusText}`);
+        }
+
+        const data = (await response.json()) as Omit<
+          ClientKey,
+          keyof ClientKeyProps
+        >;
+        return this({
+          ...props,
+          id: data.id,
+          label: data.label,
+          public: data.public,
+          secret: data.secret,
+          projectId: data.projectId,
+          isActive: data.isActive,
+          dsn: data.dsn,
+          browserSdkVersion: data.browserSdkVersion,
+          browserSdk: data.browserSdk,
+          dateCreated: data.dateCreated,
+          dynamicSdkLoaderOptions: data.dynamicSdkLoaderOptions,
+        });
+      } catch (error) {
+        console.error("Error creating/updating client key:", error);
+        throw error;
+      }
+    }
+  },
+);
+
+/**
+ * Find a client key by name
+ */
+async function findClientKeyByName(
+  api: SentryApi,
+  organization: string,
+  project: string,
+  name: string,
+): Promise<{ id: string } | null> {
+  const response = await api.get(`/projects/${organization}/${project}/keys/`);
+  if (!response.ok) {
+    throw new Error(`API error: ${response.statusText}`);
+  }
+
+  const keys = (await response.json()) as Array<{ id: string; name: string }>;
+  const key = keys.find((k) => k.name === name);
+  return key ? { id: key.id } : null;
+}

package/src/sentry/index.ts

@@ -0,0 +1,4 @@
+export * from "./api.js";
+export * from "./client-key.js";
+export * from "./project.js";
+export * from "./team.js";

package/src/sentry/project.ts

@@ -0,0 +1,420 @@
+import type { Context } from "../context.js";
+import { Resource } from "../resource.js";
+import type { Secret } from "../secret.js";
+import { SentryApi } from "./api.js";
+
+/**
+ * Properties for creating or updating a Project
+ */
+export interface ProjectProps {
+  /**
+   * The name for the project
+   */
+  name: string;
+
+  /**
+   * Uniquely identifies a project and is used for the interface
+   */
+  slug?: string;
+
+  /**
+   * The platform for the project
+   */
+  platform?: string;
+
+  /**
+   * Whether to alert on every new issue
+   */
+  defaultRules?: boolean;
+
+  /**
+   * The team slug that owns the project
+   */
+  team: string;
+
+  /**
+   * The organization ID or slug that owns the project
+   */
+  organization: string;
+
+  /**
+   * Auth token to use (overrides environment variable)
+   */
+  authToken?: Secret;
+
+  /**
+   * Whether to adopt an existing project with the same slug if it exists
+   * If true and a project with the same slug exists, it will be adopted rather than creating a new one
+   *
+   * @default false
+   */
+  adopt?: boolean;
+}
+
+/**
+ * Output returned after Project creation/update
+ */
+export interface Project
+  extends Omit<Resource<"sentry::Project">, "team">,
+    Omit<ProjectProps, "team"> {
+  /**
+   * The ID of the project
+   */
+  id: string;
+
+  /**
+   * The team that owns the project
+   */
+  team: {
+    id: string;
+    name: string;
+    slug: string;
+  };
+
+  /**
+   * All teams that have access to the project
+   */
+  teams: Array<{
+    id: string;
+    name: string;
+    slug: string;
+  }>;
+
+  /**
+   * Whether the project is bookmarked
+   */
+  isBookmarked: boolean;
+
+  /**
+   * Whether the current user is a member of the project
+   */
+  isMember: boolean;
+
+  /**
+   * Access permissions for the project
+   */
+  access: string[];
+
+  /**
+   * Whether the current user has access to the project
+   */
+  hasAccess: boolean;
+
+  /**
+   * Time at which the project was created
+   */
+  dateCreated: string;
+
+  /**
+   * List of environments in the project
+   */
+  environments: string[];
+
+  /**
+   * Event processing status
+   */
+  eventProcessing: {
+    symbolicationDegraded: boolean;
+  };
+
+  /**
+   * List of features enabled for the project
+   */
+  features: string[];
+
+  /**
+   * Whether the project has received its first event
+   */
+  firstEvent: string | null;
+
+  /**
+   * Whether the project has received its first transaction event
+   */
+  firstTransactionEvent: boolean;
+
+  /**
+   * Whether the project has sessions
+   */
+  hasSessions: boolean;
+
+  /**
+   * Whether the project has profiles
+   */
+  hasProfiles: boolean;
+
+  /**
+   * Whether the project has replays
+   */
+  hasReplays: boolean;
+
+  /**
+   * Whether the project has flags
+   */
+  hasFlags: boolean;
+
+  /**
+   * Whether the project has monitors
+   */
+  hasMonitors: boolean;
+
+  /**
+   * Whether the project has feedback
+   */
+  hasFeedbacks: boolean;
+
+  /**
+   * Whether the project has new feedback
+   */
+  hasNewFeedbacks: boolean;
+
+  /**
+   * Whether the project has minified stack traces
+   */
+  hasMinifiedStackTrace: boolean;
+
+  /**
+   * Whether the project has HTTP insights
+   */
+  hasInsightsHttp: boolean;
+
+  /**
+   * Whether the project has database insights
+   */
+  hasInsightsDb: boolean;
+
+  /**
+   * Whether the project has asset insights
+   */
+  hasInsightsAssets: boolean;
+
+  /**
+   * Whether the project has app start insights
+   */
+  hasInsightsAppStart: boolean;
+
+  /**
+   * Whether the project has screen load insights
+   */
+  hasInsightsScreenLoad: boolean;
+
+  /**
+   * Whether the project has vitals insights
+   */
+  hasInsightsVitals: boolean;
+
+  /**
+   * Whether the project has cache insights
+   */
+  hasInsightsCaches: boolean;
+
+  /**
+   * Whether the project has queue insights
+   */
+  hasInsightsQueues: boolean;
+
+  /**
+   * Whether the project has LLM monitoring
+   */
+  hasInsightsLlmMonitoring: boolean;
+
+  /**
+   * List of platforms in the project
+   */
+  platforms: string[];
+
+  /**
+   * Latest release information
+   */
+  latestRelease: string | null;
+
+  /**
+   * Whether the project has user reports
+   */
+  hasUserReports: boolean;
+
+  /**
+   * Latest deployment information
+   */
+  latestDeploys: string | null;
+}
+
+/**
+ * Create and manage Sentry projects
+ *
+ * @example
+ * // Create a basic Sentry project:
+ * const project = await Project("my-project", {
+ *   name: "My Project",
+ *   team: "my-team",
+ *   organization: "my-org"
+ * });
+ *
+ * @example
+ * // Create a project for a specific platform:
+ * const project = await Project("js-project", {
+ *   name: "JavaScript Project",
+ *   team: "my-team",
+ *   organization: "my-org",
+ *   platform: "javascript"
+ * });
+ *
+ * @example
+ * // Create a project with a custom slug and disabled default rules:
+ * const project = await Project("custom-project", {
+ *   name: "Custom Project",
+ *   team: "my-team",
+ *   organization: "my-org",
+ *   slug: "custom-project-slug",
+ *   defaultRules: false
+ * });
+ *
+ * @example
+ * // Create or adopt an existing project with the same slug:
+ * const project = await Project("existing-project", {
+ *   name: "Existing Project",
+ *   team: "my-team",
+ *   organization: "my-org",
+ *   adopt: true
+ * });
+ */
+export const Project = Resource(
+  "sentry::Project",
+  async function (
+    this: Context<Project>,
+    id: string,
+    props: ProjectProps,
+  ): Promise<Project> {
+    const api = new SentryApi({ authToken: props.authToken });
+
+    if (this.phase === "delete") {
+      try {
+        if (this.output?.id) {
+          const response = await api.delete(
+            `/projects/${props.organization}/${this.output.slug || this.output.id}/`,
+          );
+          if (!response.ok && response.status !== 404) {
+            console.error("Error deleting project:", response.statusText);
+          }
+        }
+      } catch (error) {
+        console.error("Error deleting project:", error);
+      }
+      return this.destroy();
+    } else {
+      try {
+        let response;
+
+        if (this.phase === "update" && this.output?.id) {
+          response = await api.put(
+            `/projects/${props.organization}/${this.output.slug || this.output.id}/`,
+            props,
+          );
+        } else {
+          try {
+            response = await api.post(
+              `/teams/${props.organization}/${props.team}/projects/`,
+              props,
+            );
+          } catch (error) {
+            // Check if this is a "project already exists" error and adopt is enabled
+            if (
+              props.adopt &&
+              error instanceof Error &&
+              error.message.includes("already exists")
+            ) {
+              console.log(
+                `Project '${props.slug || props.name}' already exists, adopting it`,
+              );
+              // Find the existing project by slug
+              const existingProject = await findProjectBySlug(
+                api,
+                props.organization,
+                props.slug || props.name,
+              );
+              if (!existingProject) {
+                throw new Error(
+                  `Failed to find existing project '${props.slug || props.name}' for adoption`,
+                );
+              }
+              response = await api.get(
+                `/projects/${props.organization}/${existingProject.slug}/`,
+              );
+            } else {
+              throw error;
+            }
+          }
+        }
+
+        if (!response.ok) {
+          throw new Error(`API error: ${response.statusText}`);
+        }
+
+        const data = (await response.json()) as Omit<
+          Project,
+          keyof ProjectProps
+        > & { team: Project["team"] };
+        return this({
+          ...props,
+          id: data.id,
+          team: data.team,
+          teams: data.teams,
+          isBookmarked: data.isBookmarked,
+          isMember: data.isMember,
+          access: data.access,
+          hasAccess: data.hasAccess,
+          dateCreated: data.dateCreated,
+          environments: data.environments,
+          eventProcessing: data.eventProcessing,
+          features: data.features,
+          firstEvent: data.firstEvent,
+          firstTransactionEvent: data.firstTransactionEvent,
+          hasSessions: data.hasSessions,
+          hasProfiles: data.hasProfiles,
+          hasReplays: data.hasReplays,
+          hasFlags: data.hasFlags,
+          hasMonitors: data.hasMonitors,
+          hasFeedbacks: data.hasFeedbacks,
+          hasNewFeedbacks: data.hasNewFeedbacks,
+          hasMinifiedStackTrace: data.hasMinifiedStackTrace,
+          hasInsightsHttp: data.hasInsightsHttp,
+          hasInsightsDb: data.hasInsightsDb,
+          hasInsightsAssets: data.hasInsightsAssets,
+          hasInsightsAppStart: data.hasInsightsAppStart,
+          hasInsightsScreenLoad: data.hasInsightsScreenLoad,
+          hasInsightsVitals: data.hasInsightsVitals,
+          hasInsightsCaches: data.hasInsightsCaches,
+          hasInsightsQueues: data.hasInsightsQueues,
+          hasInsightsLlmMonitoring: data.hasInsightsLlmMonitoring,
+          platforms: data.platforms,
+          latestRelease: data.latestRelease,
+          hasUserReports: data.hasUserReports,
+          latestDeploys: data.latestDeploys,
+        });
+      } catch (error) {
+        console.error("Error creating/updating project:", error);
+        throw error;
+      }
+    }
+  },
+);
+
+/**
+ * Find a project by slug
+ */
+async function findProjectBySlug(
+  api: SentryApi,
+  organization: string,
+  slug: string,
+): Promise<{ id: string; slug: string } | null> {
+  const response = await api.get(`/projects/${organization}`);
+  if (!response.ok) {
+    throw new Error(`API error: ${response.statusText}`);
+  }
+
+  const projects = (await response.json()) as Array<{
+    id: string;
+    slug: string;
+  }>;
+  const project = projects.find((p) => p.slug === slug);
+  return project ? { id: project.id, slug: project.slug } : null;
+}