@samebase/alchemy-convex 0.1.0 → 0.2.0

package/README.md

@@ -8,7 +8,7 @@ This package manages the control plane around it.
 Alchemy has no built-in Convex provider ([alchemy-run/alchemy-async#1306](https://github.com/alchemy-run/alchemy-async/issues/1306)).
 This is a community provider, maintained by [Samebase](https://samebase.com).
 
-Status: 0.1, pinned to `alchemy@2.0.0-beta.80` and Effect 4. Alchemy ships breaking changes
+Status: 0.2, pinned to `alchemy@2.0.0-beta.80` and Effect 4. Alchemy ships breaking changes
 between betas; upgrade this package and Alchemy together. Verified end to end on a Vite app with a
 Cloudflare Worker: production on `main`, a Convex preview deployment plus a Worker Preview per pull
 request, destroy on close.
@@ -52,7 +52,7 @@ export default Alchemy.Stack(
     state: Cloudflare.state(),
   },
   Effect.gen(function* () {
-    const project = yield* Convex.Project("Backend", {
+    const project = yield* Convex.Project("Project", {
       team: "my-team",
       name: "my-app",
     });
@@ -93,28 +93,83 @@ Preview stages: give `Convex.Deploy` a `PreviewDeployKey` and `previewName: <bra
 request stages, and the production key on `prod`. Variables that every preview deployment needs,
 such as auth keys, go on the project as `DefaultEnvironmentVariable` for `preview`.
 
+## Data safety
+
+Deleting a Convex project deletes all of its deployments and data. This package does not delete,
+replace, or overwrite your data by accident:
+
+- `Convex.Project` has the removal policy `retain`. When you remove the resource or run
+  `alchemy destroy`, Alchemy forgets the project and Convex keeps it. To delete the project with
+  the resource, add `RemovalPolicy.destroy()`:
+
+  ```ts
+  yield * Convex.Project("Project", { team, name }).pipe(Alchemy.RemovalPolicy.destroy());
+  ```
+
+- A project is never replaced. A change to `name` renames the project in place
+  (`PATCH /projects/{project_id}`). The id, the slug, the deployments, and the data stay.
+- A change to `team`, `deploymentType`, or `deploymentRegion` stops the deploy with
+  `ProjectTeamChange` or `ProjectDeploymentChange`. Convex cannot move a project or change its
+  first deployment. Set the old value again, or create a new resource with a new logical id and
+  move the data yourself.
+- With state, the provider finds the project only by the id in state. Without state, it finds a
+  project by its exact name, on all pages of the team's project list, and takes it over only with
+  `--adopt`. When two projects have that name, the deploy stops with `AmbiguousProject`.
+- Each `DeployKey` and `PreviewDeployKey` requests a name that is unique to the resource: the
+  `name` prop, a dash, and a hash of the resource identity. The provider deletes a key only by its
+  secret, so it cannot revoke the key of another resource. When the key list does not show
+  exactly one key with the requested name, the deploy stops with `DeployKeyRecoveryRequired`,
+  which lists the key ids. The provider never revokes a key on a failed create.
+- With an OAuth token as the credential, Convex creates no new key: it returns the OAuth token
+  with a new prefix. The key resources then stop with `DeployKeyIsCredential` and do not keep that
+  value, because a delete would revoke the OAuth token. Use a team access token or the Convex CLI
+  login.
+- An `EnvironmentVariable` or a `DefaultEnvironmentVariable` that exists but is not in state
+  belongs to someone else. The provider overwrites it only with `--adopt`.
+- A variable keeps its name and deployment (a default keeps its project, name, and deployment
+  type). A change stops the deploy with `VariableIdentityChange`. To rename or move a variable,
+  create a new resource with a new logical id and remove the old one. A rename in place would
+  need a cleanup step that can fail and leave a variable or a revoked deploy key behind.
+- A variable write runs again after a Convex write conflict or a 5xx answer, at most four more
+  times. The write sets a value, so a second write has the same result.
+
+Upgrade from 0.1: state from 0.1 records the policy `destroy` for each project. Run
+`alchemy deploy` one time with 0.2 while the stack still declares the project. That deploy records
+`retain`. Do this before you remove a project from the stack or run `alchemy destroy`.
+Deploy keys from 0.1 state keep working, but 0.2 does not delete them: their state cannot show that
+the secret is a new key and not an OAuth token. When you remove or replace such a key, delete it in
+the Convex dashboard.
+
 ## Resources
 
 - `Convex.Project`: `{ team: slug | id, name, deploymentRegion?, deploymentType? }`. Creates a
   project with its default deployment. Outputs `projectId`, `slug`, `teamId`,
-  `prodDeploymentName`, `prodDeploymentUrl`. There is no project update API, so a changed property
-  replaces the project. An existing project with the same name is adopted only with `--adopt`.
-  Deleting the resource deletes the project with all of its deployments and data.
-- `Convex.DeployKey`: `{ deployment, name, allowedActions? }`. Outputs `uniqueName` and the
-  `deployKey` secret. Any change replaces the key. Keys are never adopted: a key without its secret
-  is useless.
+  `prodDeploymentName`, `prodDeploymentUrl`. A changed `name` renames the project in place. A
+  changed `team`, `deploymentRegion`, or `deploymentType` stops the deploy. An existing project
+  with the same name is adopted only with `--adopt`. The removal policy is `retain`: only a
+  resource with `RemovalPolicy.destroy()` deletes the project with its deployments and data.
+- `Convex.DeployKey`: `{ deployment, name, allowedActions? }`. Outputs `uniqueName`, `keyId`, and
+  the `deployKey` secret. Any change replaces the key. Delete revokes the key by its secret; a key
+  from 0.1 state stays. Keys are never adopted: a key without its secret is useless.
 - `Convex.PreviewDeployKey`: `{ projectId, name }`. Project-level key for preview deployments.
-  Outputs `uniqueName` and `previewDeployKey`.
+  Outputs `uniqueName`, `keyId`, and `previewDeployKey`.
 - `Convex.EnvironmentVariable`: `{ deployment, deployKey, name, value }`. One variable on one
   deployment, set through the deployment API with that deployment's key. An existing variable with
-  the same name is adopted and overwritten.
+  the same name is adopted and overwritten only with `--adopt`. A new `value` or `deployKey` is an
+  update in place. A new `name` or `deployment` stops the deploy with `VariableIdentityChange`:
+  use a new logical id. Outputs `deployment`, `name`, and `deployKey`. Read and delete use the
+  deploy key in the outputs, not the props.
 - `Convex.DefaultEnvironmentVariable`: `{ projectId, name, value, deploymentType }`. A project
-  default that new deployments of that type inherit. Use it for preview and dev deployments.
+  default that new deployments of that type inherit. Use it for preview and dev deployments. An
+  existing default with the same name and type is adopted and overwritten only with `--adopt`. A
+  new `value` is an update in place. A new `projectId`, `name`, or `deploymentType` stops the
+  deploy with `VariableIdentityChange`: use a new logical id.
 - `Convex.Deploy`: `{ cwd?, env?, deployKey, previewName?, previewCreate?, previewRun?, extraArgs?,
 memo?, timeout? }`. Runs `npx convex deploy` with `CONVEX_DEPLOY_KEY` set and parses the
   deployment URL from the CLI output. Outputs `url`, `deploymentName`, `hash`. Memoized by content
-  hash like Alchemy's own build steps. Deleting the resource does nothing; the deployment belongs to
-  the project, and preview deployments expire on Convex's schedule.
+  hash like Alchemy's own build steps, except with `previewName` or `previewCreate`: a preview
+  deployment can expire, so a preview deploy always pushes. Deleting the resource does nothing;
+  the deployment belongs to the project, and preview deployments expire on Convex's schedule.
 
 ## Limits
 
@@ -123,6 +178,9 @@ memo?, timeout? }`. Runs `npx convex deploy` with `CONVEX_DEPLOY_KEY` set and pa
 - Deploy keys and other secret outputs are part of Alchemy state. Alchemy's Cloudflare state store
   encrypts state at rest; the local file store does not.
 - A deleted deploy key keeps working on the deployment API for roughly 30 seconds.
+- A run that stops between a key create and the state write leaves a key that state does not
+  know. The next run stops with `DeployKeyRecoveryRequired`. Delete the listed key in the Convex
+  dashboard, then run the deploy again.
 - Not covered: dev deployments, custom domains, log streams, teams and members, components,
   snapshots.
 
@@ -131,16 +189,26 @@ memo?, timeout? }`. Runs `npx convex deploy` with `CONVEX_DEPLOY_KEY` set and pa
 ```sh
 pnpm install
 pnpm run check            # format, lint, typecheck, unit tests
-pnpm run build            # lib/ with declarations
+pnpm run build            # lib/ with declarations, then publint and attw
 pnpm run test:live        # real API calls, see below
 ```
 
+Use Node 24 (`.node-version`) and pnpm 11. `pnpm install` also installs a pre-commit hook that
+runs `vp staged`.
+
 Unit tests run against recorded Management API payloads in `test/fixtures/management/`. Live tests
-need `ALCHEMY_CONVEX_LIVE=1`, a Convex login or `CONVEX_ACCESS_TOKEN`, and a throwaway project.
+run only with `ALCHEMY_CONVEX_LIVE=1`, which `pnpm run test:live` sets. They need a Convex login or
+`CONVEX_ACCESS_TOKEN`, and a throwaway project.
 Point them at yours with `ALCHEMY_CONVEX_LIVE_TEAM`, `ALCHEMY_CONVEX_LIVE_PROJECT_ID`,
 `ALCHEMY_CONVEX_LIVE_DEPLOYMENT`, and `ALCHEMY_CONVEX_LIVE_PROJECT_DIR` (a Convex app directory for
 the deploy test). They create resources named `tmp-alchemy-convex-*` and remove them again.
-
-Releases: push a `v*` tag; `.github/workflows/release.yml` publishes with npm trusted publishing.
+A file argument runs one live file only, for example
+`pnpm run test:live test/live/safety.live.test.ts`. That test runs the data safety contract
+through the Alchemy engine. It creates a project `tmp-alchemy-convex-<8 hex>` in
+`ALCHEMY_CONVEX_LIVE_TEAM` and deletes it at the end, also after a failure. It refuses to delete a
+project whose name does not start with `tmp-alchemy-convex-`.
+
+Releases: change `version` in `package.json` in a pull request. After the merge,
+`.github/workflows/release.yml` publishes that version from `main` with npm trusted publishing.
 
 License: Apache 2.0.

package/lib/index.d.ts

@@ -1,10 +1,353 @@
-export { ACCESS_TOKEN_ENV, Credentials, CredentialsError, fromConfig, fromToken, } from "./Credentials.ts";
-export { DefaultEnvironmentVariable, type DefaultEnvironmentVariableAttributes, type DefaultEnvironmentVariableProps, type DeploymentType, } from "./DefaultEnvironmentVariable.ts";
-export { Deploy, type DeployAttributes, deployArgs, type DeployProps, parseDeployOutput, } from "./Deploy.ts";
-export { DeployKey, type DeployKeyAction, type DeployKeyAttributes, type DeployKeyProps, } from "./DeployKey.ts";
-export { EnvironmentVariable, type EnvironmentVariableAttributes, type EnvironmentVariableProps, } from "./EnvironmentVariable.ts";
-export { ConvexApiError, ManagementApi } from "./ManagementApi.ts";
-export { PreviewDeployKey, type PreviewDeployKeyAttributes, type PreviewDeployKeyProps, } from "./PreviewDeployKey.ts";
-export { type DeploymentRegion, Project, type ProjectAttributes, type ProjectProps, } from "./Project.ts";
-export { Providers, providers } from "./Providers.ts";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+import { Resource } from "alchemy";
+import * as Provider from "alchemy/Provider";
+import { createDeploymentClient, createManagementClient } from "@convex-dev/platform";
+import { CommandExecutor, CommandRunProps } from "alchemy/Command";
+import { MemoOptions } from "alchemy/Command/Memo";
+import { components } from "@convex-dev/platform/managementApi";
+//#region src/Credentials.d.ts
+interface ResolvedCredentials {
+  /** Bearer token accepted by https://api.convex.dev/v1: a team access token, an OAuth token, or the Convex CLI login. */
+  readonly accessToken: Redacted.Redacted<string>;
+  /** Where the token came from, for error messages only. */
+  readonly source: "env" | "explicit" | "convex-cli-login";
+}
+declare const Credentials_base: Context.ServiceClass<Credentials, "@samebase/alchemy-convex/Credentials", Effect.Effect<ResolvedCredentials, never, never>>;
+declare class Credentials extends Credentials_base {}
+/** Environment variable read by {@link fromConfig}. */
+declare const ACCESS_TOKEN_ENV = "CONVEX_ACCESS_TOKEN";
+declare const CredentialsError_base: Schema.Class<CredentialsError, Schema.TaggedStruct<"CredentialsError", {
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class CredentialsError extends CredentialsError_base {}
+/**
+ * Default resolution: `CONVEX_ACCESS_TOKEN` from the stack ConfigProvider
+ * (process env, `.env`, stack secrets), then the Convex CLI login on this
+ * machine. CI sets the variable; a developer who ran `npx convex login` needs
+ * nothing.
+ */
+declare const fromConfig: () => Layer.Layer<Credentials>;
+/** Explicit token, for tests or callers that already hold a value. */
+declare const fromToken: (accessToken: Redacted.Redacted<string>) => Layer.Layer<Credentials>;
+//#endregion
+//#region src/ManagementApi.d.ts
+type ManagementClient = ReturnType<typeof createManagementClient>;
+type DeploymentClient = ReturnType<typeof createDeploymentClient>;
+/** Shape of every openapi-fetch result we consume. */
+interface FetchResult<T> {
+  readonly data?: T;
+  readonly error?: unknown;
+  readonly response: Response;
+}
+declare const ConvexApiError_base: Schema.Class<ConvexApiError, Schema.TaggedStruct<"ConvexApiError", {
+  readonly operation: Schema.String;
+  readonly status: Schema.Number;
+  readonly code: Schema.optionalKey<Schema.String>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * One error for every control-plane and deployment call. Resources branch on
+ * `status` (404 means absent for read and delete), so the class is load
+ * bearing, not decorative.
+ */
+declare class ConvexApiError extends ConvexApiError_base {}
+interface ManagementApiService {
+  /** Run one management call with the resolved credentials. */
+  readonly request: <T>(operation: string, run: (client: ManagementClient) => Promise<FetchResult<T>>) => Effect.Effect<T, ConvexApiError>;
+  /** Run one management call whose success response has no body. */
+  readonly requestVoid: (operation: string, run: (client: ManagementClient) => Promise<FetchResult<unknown>>) => Effect.Effect<void, ConvexApiError>;
+  /** Run one deployment-scoped call authenticated with a deploy key. */
+  readonly deploymentRequest: <T>(operation: string, deploymentUrlOrName: string, deployKey: Redacted.Redacted<string>, run: (client: DeploymentClient) => Promise<FetchResult<T>>) => Effect.Effect<T, ConvexApiError>;
+  /** Team id for a slug or numeric id. */
+  readonly resolveTeamId: (team: string | number) => Effect.Effect<number, ConvexApiError>;
+  /**
+   * True when a deploy key that Convex returned carries the token of the
+   * Management API credential itself. With an OAuth token, create_deploy_key
+   * and create_preview_deploy_key create no new key: they return the OAuth
+   * token with a new prefix, and the part after "|" is the same. A delete of
+   * that key would revoke the credential.
+   */
+  readonly isCredentialToken: (secret: string) => Effect.Effect<boolean>;
+}
+declare const ManagementApi_base: Context.ServiceClass<ManagementApi, "@samebase/alchemy-convex/ManagementApi", ManagementApiService>;
+declare class ManagementApi extends ManagementApi_base {}
+//#endregion
+//#region src/Providers.d.ts
+declare const Providers_base: Provider.ProviderCollection<Providers, "Convex">;
+declare class Providers extends Providers_base {}
+/**
+ * All Convex resource providers. Pass a credentials layer to override the
+ * default lookup (`CONVEX_ACCESS_TOKEN`, then the Convex CLI login).
+ */
+declare const providers: (credentials?: Layer.Layer<Credentials>) => Layer.Layer<Providers, never, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/FileSystem").FileSystem | import("effect/Path").Path>;
+//#endregion
+//#region src/DefaultEnvironmentVariable.d.ts
+/** Deployment types a default can target, from the generated schema. */
+type DeploymentType = components["schemas"]["DeploymentType"];
+interface DefaultEnvironmentVariableProps {
+  /** Numeric project id, such as `project.projectId`. */
+  readonly projectId: number;
+  readonly name: string;
+  readonly value: string | Redacted.Redacted<string>;
+  /** Deployments of this type that Convex creates from now on get the variable. */
+  readonly deploymentType: DeploymentType;
+}
+interface DefaultEnvironmentVariableAttributes {
+  readonly projectId: number;
+  readonly name: string;
+  readonly deploymentType: DeploymentType;
+}
+type DefaultEnvironmentVariable = Resource<"Convex.DefaultEnvironmentVariable", DefaultEnvironmentVariableProps, DefaultEnvironmentVariableAttributes, never, Providers>;
+declare const DefaultEnvironmentVariable: import("alchemy").ResourceClass<DefaultEnvironmentVariable>;
+//#endregion
+//#region src/Deploy.d.ts
+interface DeployProps extends Pick<CommandRunProps, "cwd" | "env" | "timeout"> {
+  /**
+   * Deploy key that selects the target deployment: a production, development,
+   * project, or preview deploy key. The CLI receives it as `CONVEX_DEPLOY_KEY`,
+   * and Alchemy removes its value from the logged output.
+   */
+  readonly deployKey: Redacted.Redacted<string>;
+  /**
+   * Preview deployment name for a preview deploy key. The CLI reuses an
+   * existing preview deployment with this name.
+   */
+  readonly previewName?: string;
+  /**
+   * Like {@link previewName}, but the CLI deletes and recreates an existing
+   * preview deployment with this name, so every run gets a new URL.
+   */
+  readonly previewCreate?: string;
+  /**
+   * Function to run after the push, such as `init:seed`. The CLI runs it only
+   * when the push created a new preview deployment.
+   */
+  readonly previewRun?: string;
+  /**
+   * More `convex deploy` flags, added after the preview flags. Alchemy splits
+   * the command on whitespace, so an argument cannot contain whitespace: use
+   * `--typecheck=disable`, not `--typecheck disable` as one argument.
+   */
+  readonly extraArgs?: readonly string[];
+  /**
+   * Files hashed to skip an unchanged push. By default every non-gitignored
+   * file under `cwd` and the nearest lockfile. Use
+   * `{ include: ["convex/**"], lockfile: true }` to ignore frontend changes,
+   * or `false` to push on every deploy. A preview deploy (`previewName` or
+   * `previewCreate`) pushes on every deploy: Convex can delete an expired
+   * preview deployment, and the hash cannot show that.
+   * @default true
+   */
+  readonly memo?: MemoOptions | boolean;
+}
+interface DeployAttributes {
+  /** Client URL of the deployment that received the push, such as `https://happy-otter-123.convex.cloud`. */
+  readonly url: string;
+  /** First label of the URL host, such as `happy-otter-123`. */
+  readonly deploymentName: string;
+  /** Hash of the memoized input files after the push, or `undefined` when `memo` is `false`. */
+  readonly hash: string | undefined;
+}
+type Deploy = Resource<"Convex.Deploy", DeployProps, DeployAttributes, never, Providers>;
+declare const Deploy: import("alchemy").ResourceClass<Deploy>;
+/** Reads the deployment URL from `convex deploy` output. ANSI escape codes are removed first. */
+declare const parseDeployOutput: (text: string) => {
+  url: string;
+  deploymentName: string;
+} | undefined;
+/** The `convex deploy` argv, starting with `npx`. */
+declare const deployArgs: (props: Pick<DeployProps, "previewName" | "previewCreate" | "previewRun" | "extraArgs">) => readonly string[];
+declare const DeployArgumentError_base: Schema.Class<DeployArgumentError, Schema.TaggedStruct<"DeployArgumentError", {
+  readonly argument: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A `convex deploy` argument contains whitespace, which Alchemy's command runner splits on. */
+declare class DeployArgumentError extends DeployArgumentError_base {
+  get message(): string;
+}
+declare const DeployOutputError_base: Schema.Class<DeployOutputError, Schema.TaggedStruct<"DeployOutputError", {
+  readonly outputTail: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** `npx convex deploy` exited 0 but did not print the deployment URL. */
+declare class DeployOutputError extends DeployOutputError_base {
+  get message(): string;
+}
+//#endregion
+//#region src/DeployKey.d.ts
+/** Actions a deploy key can be limited to, from the generated schema. */
+type DeployKeyAction = NonNullable<components["schemas"]["PlatformCreateDeployKeyArgs"]["allowedActions"]>[number];
+declare const DeployKeyRecoveryRequired_base: Schema.Class<DeployKeyRecoveryRequired, Schema.TaggedStruct<"DeployKeyRecoveryRequired", {
+  /** Where the keys live, such as `deployment happy-otter-123` or `project 3145389`. */
+  readonly target: Schema.String;
+  /** The requested name. */
+  readonly name: Schema.String;
+  /** The listed keys with the requested name. */
+  readonly keys: Schema.$Array<Schema.Struct<{
+    readonly id: Schema.Number;
+    readonly name: Schema.String;
+  }>>;
+  /** True when this run created a key before the listing check failed. */
+  readonly afterCreate: Schema.Boolean;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A key cannot be tied to one resource: before the create, listed keys
+ * already have the requested name, or after the create, not exactly one has it.
+ */
+declare class DeployKeyRecoveryRequired extends DeployKeyRecoveryRequired_base {
+  get message(): string;
+}
+declare const DeployKeyIsCredential_base: Schema.Class<DeployKeyIsCredential, Schema.TaggedStruct<"DeployKeyIsCredential", {
+  readonly target: Schema.String;
+  readonly name: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Convex returned the Management API credential itself as the new key. This
+ * happens with an OAuth token: Convex creates no key. A delete of the
+ * returned secret would revoke the credential, so the resource does not keep it.
+ */
+declare class DeployKeyIsCredential extends DeployKeyIsCredential_base {
+  get message(): string;
+}
+interface DeployKeyProps {
+  /** Deployment name, such as `project.prodDeploymentName`. */
+  readonly deployment: string;
+  /**
+   * Key name. The provider requests this name, a dash, and a hash of the
+   * resource identity, so two resources with one `name` get different keys.
+   */
+  readonly name: string;
+  /** Limits the key to these actions. Convex grants every deployment action when omitted. */
+  readonly allowedActions?: readonly DeployKeyAction[];
+}
+interface DeployKeyAttributes {
+  /** The name Convex lists the key under, such as "ci-3f2a1b0c9d8e". */
+  readonly uniqueName: string;
+  /** Numeric id of the key in the listing. Undefined in state written by 0.1.x. */
+  readonly keyId: number | undefined;
+  readonly deployment: string;
+  /** The secret, such as `prod:<deployment>|<token>`. Convex returns it only at creation. */
+  readonly deployKey: Redacted.Redacted<string>;
+}
+type DeployKey = Resource<"Convex.DeployKey", DeployKeyProps, DeployKeyAttributes, never, Providers>;
+declare const DeployKey: import("alchemy").ResourceClass<DeployKey>;
+//#endregion
+//#region src/EnvironmentVariable.d.ts
+interface EnvironmentVariableProps {
+  /** Deployment name, or its URL for deployments outside US East. */
+  readonly deployment: string;
+  /** Deploy key for `deployment`, such as `deployKey.deployKey`. */
+  readonly deployKey: Redacted.Redacted<string>;
+  readonly name: string;
+  readonly value: string | Redacted.Redacted<string>;
+}
+interface EnvironmentVariableAttributes {
+  readonly deployment: string;
+  readonly name: string;
+  /** Deploy key for `deployment`, for read and delete. Undefined in state from 0.1.x. */
+  readonly deployKey: Redacted.Redacted<string> | undefined;
+}
+type EnvironmentVariable = Resource<"Convex.EnvironmentVariable", EnvironmentVariableProps, EnvironmentVariableAttributes, never, Providers>;
+declare const EnvironmentVariable: import("alchemy").ResourceClass<EnvironmentVariable>;
+declare const VariableIdentityChange_base: Schema.Class<VariableIdentityChange, Schema.TaggedStruct<"VariableIdentityChange", {
+  readonly resourceType: Schema.String;
+  readonly field: Schema.Literals<readonly ["name", "deployment", "projectId", "deploymentType"]>;
+  readonly current: Schema.String;
+  readonly requested: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The props name another variable than the one in state. Used by
+ * Convex.EnvironmentVariable and Convex.DefaultEnvironmentVariable.
+ */
+declare class VariableIdentityChange extends VariableIdentityChange_base {
+  get message(): string;
+}
+//#endregion
+//#region src/PreviewDeployKey.d.ts
+interface PreviewDeployKeyProps {
+  /** Numeric project id, such as `project.projectId`. */
+  readonly projectId: number;
+  /**
+   * Key name. The provider requests this name, a dash, and a hash of the
+   * resource identity, so two resources with one `name` get different keys.
+   */
+  readonly name: string;
+}
+interface PreviewDeployKeyAttributes {
+  /** The name Convex lists the key under, such as "ci-3f2a1b0c9d8e". */
+  readonly uniqueName: string;
+  /** Numeric id of the key in the listing. Undefined in state written by 0.1.x. */
+  readonly keyId: number | undefined;
+  readonly projectId: number;
+  /** The secret, such as `preview:<team>:<project>|<token>`. Convex returns it only at creation. */
+  readonly previewDeployKey: Redacted.Redacted<string>;
+}
+type PreviewDeployKey = Resource<"Convex.PreviewDeployKey", PreviewDeployKeyProps, PreviewDeployKeyAttributes, never, Providers>;
+declare const PreviewDeployKey: import("alchemy").ResourceClass<PreviewDeployKey>;
+//#endregion
+//#region src/Project.d.ts
+/** Region names the Management API accepts, from the generated schema. */
+type DeploymentRegion = components["schemas"]["RegionName"];
+interface ProjectProps {
+  /** Team slug or numeric team id. A slug costs one extra lookup per run. Cannot change. */
+  readonly team: string | number;
+  /** Display name. Convex derives the slug from it at creation. A change renames the project. */
+  readonly name: string;
+  /** Region of the deployment created with the project. Defaults to the team default. Cannot change. */
+  readonly deploymentRegion?: DeploymentRegion;
+  /** Deployment created with the project. Defaults to `prod`. Cannot change. */
+  readonly deploymentType?: "prod" | "dev";
+}
+interface ProjectAttributes {
+  readonly projectId: number;
+  readonly slug: string;
+  readonly name: string;
+  readonly teamId: number;
+  readonly prodDeploymentName: string | undefined;
+  readonly prodDeploymentUrl: string | undefined;
+}
+type Project = Resource<"Convex.Project", ProjectProps, ProjectAttributes, never, Providers>;
+declare const Project: import("alchemy").ResourceClass<Project>;
+declare const ProjectTeamChange_base: Schema.Class<ProjectTeamChange, Schema.TaggedStruct<"ProjectTeamChange", {
+  readonly projectId: Schema.Number;
+  readonly teamId: Schema.Number;
+  readonly requestedTeamId: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/** The props change the team of an existing project. Convex cannot move a project. */
+declare class ProjectTeamChange extends ProjectTeamChange_base {
+  get message(): string;
+}
+declare const ProjectDeploymentChange_base: Schema.Class<ProjectDeploymentChange, Schema.TaggedStruct<"ProjectDeploymentChange", {
+  readonly projectId: Schema.Number;
+  readonly field: Schema.Literals<readonly ["deploymentType", "deploymentRegion"]>;
+  readonly current: Schema.UndefinedOr<Schema.String>;
+  readonly requested: Schema.UndefinedOr<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The props change `deploymentType` or `deploymentRegion` of an existing
+ * project. Convex uses them only when it creates the project.
+ */
+declare class ProjectDeploymentChange extends ProjectDeploymentChange_base {
+  get message(): string;
+}
+declare const AmbiguousProject_base: Schema.Class<AmbiguousProject, Schema.TaggedStruct<"AmbiguousProject", {
+  readonly teamId: Schema.Number;
+  readonly name: Schema.String;
+  readonly projectIds: Schema.$Array<Schema.Number>;
+}>, import("effect/Cause").YieldableError>;
+/** More than one project in the team has the name, so the lookup cannot choose one. */
+declare class AmbiguousProject extends AmbiguousProject_base {
+  get message(): string;
+}
+declare const CreatedProjectNotFound_base: Schema.Class<CreatedProjectNotFound, Schema.TaggedStruct<"CreatedProjectNotFound", {
+  readonly projectId: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/** Convex answered a create call but then did not return the project. */
+declare class CreatedProjectNotFound extends CreatedProjectNotFound_base {
+  get message(): string;
+}
+//#endregion
+export { ACCESS_TOKEN_ENV, AmbiguousProject, ConvexApiError, CreatedProjectNotFound, Credentials, CredentialsError, DefaultEnvironmentVariable, type DefaultEnvironmentVariableAttributes, type DefaultEnvironmentVariableProps, Deploy, DeployArgumentError, type DeployAttributes, DeployKey, type DeployKeyAction, type DeployKeyAttributes, DeployKeyIsCredential, type DeployKeyProps, DeployKeyRecoveryRequired, DeployOutputError, type DeployProps, type DeploymentRegion, type DeploymentType, EnvironmentVariable, type EnvironmentVariableAttributes, type EnvironmentVariableProps, ManagementApi, PreviewDeployKey, type PreviewDeployKeyAttributes, type PreviewDeployKeyProps, Project, type ProjectAttributes, ProjectDeploymentChange, type ProjectProps, ProjectTeamChange, Providers, VariableIdentityChange, deployArgs, fromConfig, fromToken, parseDeployOutput, providers };
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,UAAU,EACV,SAAS,GACV,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,0BAA0B,EAC1B,KAAK,oCAAoC,EACzC,KAAK,+BAA+B,EACpC,KAAK,cAAc,GACpB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,MAAM,EACN,KAAK,gBAAgB,EACrB,UAAU,EACV,KAAK,WAAW,EAChB,iBAAiB,GAClB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,SAAS,EACT,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,cAAc,GACpB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,mBAAmB,EACnB,KAAK,6BAA6B,EAClC,KAAK,wBAAwB,GAC9B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,EACL,gBAAgB,EAChB,KAAK,0BAA0B,EAC/B,KAAK,qBAAqB,GAC3B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,KAAK,gBAAgB,EACrB,OAAO,EACP,KAAK,iBAAiB,EACtB,KAAK,YAAY,GAClB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/Credentials.ts","../src/ManagementApi.ts","../src/Providers.ts","../src/DefaultEnvironmentVariable.ts","../src/Deploy.ts","../src/DeployKey.ts","../src/EnvironmentVariable.ts","../src/PreviewDeployKey.ts","../src/Project.ts"],"mappings":";;;;;;;;;;;;UAgBiB;;WAEN,aAAa,SAAS;;WAEtB;;;cAGE,oBAAoB;;cAKpB;;;;cAyBA,yBAAyB;;;;;;;cAUzB,kBAAiB,MAAM,MAAM;;cAa7B,YAAa,aAAa,SAAS,qBAAmB,MAAM,MAAM;;;KC7DnE,mBAAmB,kBAAkB;KACrC,mBAAmB,kBAAkB;;UAGhC,YAAY;WAClB,OAAO;WACP;WACA,UAAU;;;;;;;;;;;;;cAQR,uBAAuB;UAuBnB;;WAEN,UAAU,GACjB,mBACA,MAAM,QAAQ,qBAAqB,QAAQ,YAAY,QACpD,OAAO,OAAO,GAAG;;WAEb,cACP,mBACA,MAAM,QAAQ,qBAAqB,QAAQ,0BACxC,OAAO,aAAa;;WAEhB,oBAAoB,GAC3B,mBACA,6BACA,WAAW,SAAS,kBACpB,MAAM,QAAQ,qBAAqB,QAAQ,YAAY,QACpD,OAAO,OAAO,GAAG;;WAEb,gBAAgB,0BAA0B,OAAO,eAAe;;;;;;;;WAQhE,oBAAoB,mBAAmB,OAAO;;;cAM5C,sBAAsB;;;;cCrEtB,kBAAkB;;;;;cAMlB,YAAa,cAAa,MAAM,MAAM,iBAA2B,MAAA,MAAA,+DAAA,kDAAA,mCAAA;;;;KCalE,iBAAiB;UAgGZ;;WAEN;WACA;WACA,gBAAgB,SAAS;;WAEzB,gBAAgB;;UAGV;WACN;WACA;WACA,gBAAgB;;KAGf,6BAA6B,8CAEvC,iCACA,6CAEA;cAEW,8CAA0B,cAAA;;;UCzItB,oBAAoB,KAAK;;;;;;WAM/B,WAAW,SAAS;;;;;WAKpB;;;;;WAKA;;;;;WAKA;;;;;;WAMA;;;;;;;;;;WAUA,OAAO;;UAGD;;WAEN;;WAEA;;WAEA;;KAGC,SAAS,0BAA0B,aAAa,yBAAyB;cACxE,0BAAM,cAAA;;cAYN,oBACX;EACG;EAAa;;;cAQL,aACX,OAAO,KAAK;;;;;cAeD,4BAA4B;MAI1B;;;;;;cAMF,0BAA0B;MAIxB;;;;;KC/EH,kBAAkB,YAC5B;;;;;;;;;;;;;;;;;;cA6DW,kCAAkC;MAahC;;;;;;;;;;;cAgBF,8BAA8B;MAI5B;;UAwEE;;WAEN;;;;;WAKA;;WAEA,0BAA0B;;UAGpB;;WAEN;;WAEA;WACA;;WAEA,WAAW,SAAS;;KAGnB,YAAY,6BAEtB,gBACA,4BAEA;cAEW,6BAAS,cAAA;;;UC/HL;;WAEN;;WAEA,WAAW,SAAS;WACpB;WACA,gBAAgB,SAAS;;UAGnB;WACN;WACA;;WAEA,WAAW,SAAS;;KAGnB,sBAAsB,uCAEhC,0BACA,sCAEA;cAEW,uCAAmB,cAAA;;;;;;;;;;;cAMnB,+BAA+B;MAS7B;;;;UCpHE;;WAEN;;;;;WAKA;;UAGM;;WAEN;;WAEA;WACA;;WAEA,kBAAkB,SAAS;;KAG1B,mBAAmB,oCAE7B,uBACA,mCAEA;cAEW,oCAAgB,cAAA;;;;KChCjB,mBAAmB;UAEd;;WAEN;;WAEA;;WAEA,mBAAmB;;WAEnB;;UAGM;WACN;WACA;WACA;WACA;WACA;WACA;;KAGC,UAAU,2BAA2B,cAAc,0BAA0B;cAC5E,2BAAO,cAAA;;;;;;;cAGP,0BAA0B;MAIxB;;;;;;;;;;;;cASF,gCAAgC;MAS9B;;;;;;;;cAOF,yBAAyB;MAKvB;;;;;;cAMF,+BAA+B;MAI7B"}