alchemy 0.73.0 → 0.74.0

package/src/prisma-postgres/api.ts

@@ -0,0 +1,79 @@
+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 { PrismaClient } from "./api/sdk.gen.ts";
+
+export interface PrismaApiOptions {
+  /**
+   * The service token to use for the API
+   */
+  serviceToken?: Secret<string>;
+}
+
+export class PrismaApi 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 Prisma 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 PrismaApi instance with environment variable fallback
+ * @param options API options
+ * @returns PrismaApi instance
+ */
+export function createPrismaApi(
+  options: Partial<PrismaApiOptions> = {},
+): PrismaClient {
+  const serviceToken =
+    options.serviceToken?.unencrypted ?? process.env.PRISMA_SERVICE_TOKEN;
+  if (!serviceToken) {
+    throw new Error("PRISMA_SERVICE_TOKEN is not set");
+  }
+  const client = createClient(
+    createConfig<ClientOptions>({
+      baseUrl: "https://api.prisma.io",
+      throwOnError: true,
+      headers: {
+        Authorization: `Bearer ${serviceToken}`,
+      },
+    }),
+  );
+
+  client.interceptors.error.use((error, response, request, options) => {
+    if (options.throwOnError !== false) {
+      throw new PrismaApi({
+        error: error as {
+          status?: number;
+          error?: string;
+        },
+        request,
+        response,
+      });
+    }
+  });
+
+  return new PrismaClient({
+    client,
+  });
+}

package/src/prisma-postgres/connection.ts

@@ -0,0 +1,154 @@
+import type { Context } from "../context.ts";
+import { Resource } from "../resource.ts";
+import { secret, type Secret } from "../secret.ts";
+import { createPrismaApi } from "./api.ts";
+import type { Database } from "./database.ts";
+
+export interface ConnectionProps {
+  /**
+   * Database (id or resource) the connection belongs to
+   */
+  database: Database | string;
+
+  /**
+   * The name of the connection
+   */
+  name?: string;
+
+  /**
+   * The service token to use for the API
+   */
+  serviceToken?: Secret<string>;
+}
+
+export interface Connection {
+  /**
+   * The prisma id of the connection
+   */
+  id: string;
+
+  /**
+   * The name of the connection
+   */
+  name: string;
+
+  /**
+   * The timestamp of the connection creation
+   */
+  createdAt: string;
+
+  /**
+   * The prisma connection string (prefixed with `prisma+postgres://`)
+   */
+  prismaConnectionString: Secret<string>;
+
+  /**
+   * The connection string
+   */
+  connectionString: Secret<string>;
+
+  /**
+   * The prisma id of the database the connection belongs to
+   */
+  database: string;
+
+  /**
+   * The host of the connection
+   */
+  host: string | null;
+
+  /**
+   * The password of the connection
+   */
+  password: Secret<string> | null;
+
+  /**
+   * The user of the connection
+   */
+  user: string | null;
+}
+
+/**
+ * Creates and manages Prisma Postgres database connections.
+ *
+ * Prisma Postgres database connections provide secure credentials
+ * and connection details for accessing your databases. Connections
+ * belong to a Prisma Postgres database.
+ *
+ * @example
+ * // Create a database connection for a database
+ * import { Database, Connection } from "alchemy/prisma-postgres";
+ * const project = await Project("my-project");
+ * const database = await Database("my-database", { project });
+ * const connection = await Connection("my-connection", {
+ *   database: database,
+ * });
+ * console.log(`Connection String: ${connection.connectionString.unencrypted}`);
+ *
+ * @example
+ * // Create a database connection and connect it to Cloudflare Hyperdrive
+ * import { Hyperdrive } from "alchemy/cloudflare";
+ * import { Database, Connection } from "alchemy/prisma-postgres";
+ * const project = await Project("my-project");
+ * const database = await Database("my-database", { project });
+ * const connection = await Connection("my-connection", {
+ *   database: database,
+ * });
+ * const db = await Hyperdrive("prisma-postgres", {
+ *   origin: connection.connectionString.unencrypted,
+ * });
+ */
+export const Connection = Resource(
+  "prisma::Connection",
+  async function (
+    this: Context<Connection>,
+    id: string,
+    props: ConnectionProps,
+  ): Promise<Connection> {
+    const api = createPrismaApi({
+      serviceToken: props.serviceToken,
+    });
+    const name =
+      props.name ?? this.output?.name ?? this.scope.createPhysicalName(id);
+    const database =
+      typeof props.database === "string" ? props.database : props.database.id;
+
+    if (this.phase === "delete") {
+      await api.deleteDatabaseConnectionString({
+        path: {
+          id: this.output.id,
+        },
+      });
+      return this.destroy();
+    }
+
+    if (this.phase === "update") {
+      return this.replace();
+    }
+
+    const connection = await api
+      .createDatabaseConnectionString({
+        path: {
+          databaseId: database,
+        },
+        body: {
+          name,
+        },
+      })
+      .then((response) => response.data.data);
+
+    return {
+      id: connection.id,
+      name: connection.name,
+      createdAt: connection.createdAt,
+      prismaConnectionString: secret(connection.connectionString),
+      connectionString: secret(
+        `postgres://${connection.user}:${connection.pass}@${connection.host}/${connection.database}`,
+      ),
+      database: database,
+      host: connection.host,
+      password: connection.pass ? secret(connection.pass) : null,
+      user: connection.user,
+    };
+  },
+);

package/src/prisma-postgres/database.ts

@@ -0,0 +1,178 @@
+import type { Context } from "../context.ts";
+import { Resource } from "../resource.ts";
+import type { Secret } from "../secret.ts";
+import { createPrismaApi } from "./api.ts";
+import type { CreateDatabaseData } from "./api/types.gen.ts";
+import type { Project } from "./project.ts";
+
+export interface DatabaseProps {
+  /**
+   * The name of the database
+   */
+
+  project: Project | string;
+  /**
+   * The region to create the database in
+   */
+
+  name?: string;
+  /**
+   * The project to create the database in
+   */
+
+  region?:
+    | "us-east-1"
+    | "us-west-1"
+    | "eu-west-3"
+    | "eu-central-1"
+    | "ap-northeast-1"
+    | "ap-southeast-1"
+    | (string & {});
+
+  /**
+   * Whether to delete the database if the resource is deleted
+   *
+   * @default false
+   */
+  delete?: boolean;
+
+  /**
+   * The service token to use for the API
+   */
+  serviceToken?: Secret<string>;
+}
+
+export interface Database {
+  /**
+   * The prisma id of the database
+   */
+  id: string;
+
+  /**
+   * The name of the database
+   */
+  name: string;
+
+  /**
+   * The status of the database
+   */
+  status: "failure" | "provisioning" | "ready" | "recovering";
+
+  /**
+   * The region of the database
+   */
+  region?: string;
+
+  /**
+   * The timestamp of the database creation
+   */
+  createdAt: string;
+
+  /**
+   * The prisma id of the project the database belongs to
+   */
+  project: string;
+}
+
+/**
+ * Creates and manages Prisma Postgres databases.
+ *
+ * Prisma Postgres databases are fully managed PostgreSQL instances
+ * that can be connected to applications. Databases belong to a
+ * Prisma Postgres project.
+ *
+ * @example
+ * // Create a database for a project
+ * import { Project, Database } from "alchemy/prisma-postgres";
+ * const project = await Project("my-app");
+ * const database = await Database("my-database", {
+ *   project: project,
+ * });
+ *
+ * @example
+ * // Create a database in the asia pacific region
+ * import { Project, Database } from "alchemy/prisma-postgres";
+ * const project = await Project("my-app");
+ * const database = await Database("my-database", {
+ *   project: project,
+ *   region: "ap-northeast-1",
+ * });
+ *
+ * @example
+ * // Create a database and fully delete on destroy
+ * import { Project, Database } from "alchemy/prisma-postgres";
+ * const project = await Project("my-app");
+ * const database = await Database("my-database", {
+ *   project: project,
+ *   delete: true,
+ * });
+ */
+export const Database = Resource(
+  "prisma::Database",
+  async function (
+    this: Context<Database>,
+    id: string,
+    props: DatabaseProps,
+  ): Promise<Database> {
+    const api = createPrismaApi({
+      serviceToken: props.serviceToken,
+    });
+    const name =
+      props.name ?? this.output?.name ?? this.scope.createPhysicalName(id);
+    const shouldDelete = props.delete ?? false;
+    const project =
+      typeof props.project === "string" ? props.project : props.project.id;
+
+    if (this.phase === "delete") {
+      if (shouldDelete) {
+        await api.deleteDatabase({
+          path: { databaseId: this.output.id },
+        });
+      }
+      return this.destroy();
+    }
+
+    if (this.phase === "update") {
+      return this.replace();
+    }
+
+    const database = await api
+      .createDatabase({
+        path: {
+          projectId: project,
+        },
+        body: {
+          isDefault: false,
+          name,
+          region: props.region,
+        } as CreateDatabaseData["body"],
+      })
+      .then((response) => response.data.data);
+
+    return {
+      id: database.id,
+      name: database.name,
+      region: database.region?.id,
+      status: database.status,
+      createdAt: database.createdAt,
+      project,
+    };
+  },
+);
+
+export async function findDatabaseByName(props: DatabaseProps) {
+  const api = createPrismaApi({
+    serviceToken: props.serviceToken,
+  });
+
+  const project =
+    typeof props.project === "string" ? props.project : props.project.id;
+
+  const databases = await api.listDatabases({
+    path: {
+      projectId: project,
+    },
+  });
+  const database = databases.data.data.find((db) => db.name === props.name);
+  return database;
+}

package/src/prisma-postgres/index.ts

@@ -0,0 +1,4 @@
+export * from "./connection.ts";
+export * from "./database.ts";
+export * from "./project.ts";
+export * from "./workspace.ts";

package/src/prisma-postgres/project.ts

@@ -0,0 +1,131 @@
+import type { Context } from "../context.ts";
+import { Resource } from "../resource.ts";
+import type { Secret } from "../secret.ts";
+import { createPrismaApi } from "./api.ts";
+
+export interface ProjectProps {
+  /**
+   * The name of the project
+   */
+  name?: string;
+
+  /**
+   * Whether to delete the project if the resource is deleted
+   *
+   * @default false
+   */
+  delete?: boolean;
+
+  /**
+   * The service token to use for the API
+   */
+  serviceToken?: Secret<string>;
+}
+
+export interface Project {
+  /**
+   * The prisma id of the project
+   */
+  id: string;
+
+  /**
+   * The name of the project
+   */
+  name: string;
+
+  /**
+   * The timestamp of the project creation
+   */
+  createdAt: string;
+
+  /**
+   * The workspace the project belongs to
+   */
+  workspace: {
+    /**
+     * The prisma id of the workspace
+     */
+    id: string;
+
+    /**
+     * The name of the workspace
+     */
+    name: string;
+  };
+}
+
+/**
+ * Creates and manages Prisma Postgres projects.
+ *
+ * Prisma Postgres projects are containers for your databases and
+ * their configurations. Projects belong to a workspace and can
+ * contain multiple databases.
+ *
+ * @example
+ * // Create a database for a project
+ * import { Project, Database } from "alchemy/prisma-postgres";
+ * const project = await Project("my-app");
+ */
+export const Project = Resource(
+  "prisma::Project",
+  async function (
+    this: Context<Project>,
+    id: string,
+    props?: ProjectProps,
+  ): Promise<Project> {
+    const api = createPrismaApi({
+      serviceToken: props?.serviceToken,
+    });
+    const name =
+      props?.name ?? this.output?.name ?? this.scope.createPhysicalName(id);
+    const shouldDelete = props?.delete ?? false;
+
+    if (this.phase === "delete") {
+      if (shouldDelete) {
+        await api.deleteProject({
+          path: { id: this.output.id },
+        });
+      }
+      return this.destroy();
+    }
+    if (this.phase === "update") {
+      return this.replace();
+    }
+
+    const project = await api
+      .createProjectWithPostgresDatabase({
+        body: {
+          createDatabase: false,
+          name,
+          //! prisma seems to not support setting the workspace on project creation?
+        },
+      })
+      .then((response) => response.data.data!);
+
+    return {
+      id: project.id,
+      name: project.name,
+      createdAt: project.createdAt,
+      workspace: project.workspace,
+    };
+  },
+);
+
+export async function findProjectByName(props: ProjectProps) {
+  const api = createPrismaApi(props);
+  let hasMore = true;
+  let project:
+    | NonNullable<
+        Awaited<ReturnType<typeof api.listProjects>>["data"]
+      >["data"][number]
+    | undefined;
+  while (hasMore) {
+    const response = await api.listProjects();
+    project = response.data.data.find((project) => project.name === props.name);
+    if (project != null) {
+      break;
+    }
+    hasMore = response.data.pagination.hasMore;
+  }
+  return project;
+}

package/src/prisma-postgres/workspace.ts

@@ -0,0 +1,27 @@
+import { createPrismaApi, type PrismaApiOptions } from "./api.ts";
+
+/**
+ * Get a prisma workspace by id or name.
+ *
+ * @example
+ * const workspace = await WorkspaceRef("alchemy-test");
+ *
+ * @param identifier The id or name of the workspace to get.
+ * @param props The api credentials to use.
+ * @returns The workspace.
+ */
+export async function WorkspaceRef(
+  identifier: string,
+  props?: PrismaApiOptions,
+) {
+  const api = createPrismaApi(props);
+
+  const workspaces = await api.listWorkspaces();
+  const workspace = workspaces.data.data.find(
+    (workspace) => workspace.id === identifier || workspace.name === identifier,
+  );
+  if (!workspace) {
+    throw new Error(`Workspace with identifier ${identifier} not found`);
+  }
+  return workspace;
+}