alchemy 2.0.0-beta.84 → 2.0.0-beta.85

package/src/Alchemist/{routes/state.ts → State.ts}

@@ -3,12 +3,18 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Stream from "effect/Stream";
-import { AuthProviders } from "../../Auth/AuthProvider.ts";
-import { withProfileOverride } from "../../Auth/Resolve.ts";
-import * as Contributions from "../../Contributions.ts";
-import * as State from "../../State/index.ts";
-import { loadConfigProvider } from "../../Util/ConfigProvider.ts";
-import { open, StackEntrypointError, type Target } from "../Session.ts";
+import { AuthProvidersLive } from "../Auth/Registry.ts";
+import { withProfileOverride } from "../Auth/Resolve.ts";
+import * as Contributions from "../Contributions.ts";
+import * as State from "../State/index.ts";
+import { loadConfigProvider } from "../Util/ConfigProvider.ts";
+import {
+  DEFAULT_ENTRYPOINT,
+  importStack,
+  StackEntrypointError,
+  type Target,
+} from "./Entrypoint.ts";
+import { buildWithoutProgram, PLACEHOLDER_STAGE } from "./Operations.ts";
 
 /**
  * Build a provider's layers from scratch: the process may already have built
@@ -21,19 +27,23 @@ const isolated = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
 /** Which store a state request addresses. */
 export type StateSource =
   /** `.alchemy/` on this machine, ignoring whatever the project configures. */
-  | { readonly _tag: "Local" }
+  | { readonly type: "local" }
   /** Whatever the project's entrypoint configures. */
-  | ({ readonly _tag: "Configured" } & Target)
+  | ({
+      readonly type: "configured";
+      /** Stage the store is opened for. @default "placeholder" */
+      readonly stage?: string;
+    } & Target)
   /** A provider's state store, without loading a project entrypoint. */
   | ({
-      readonly _tag: "Provider";
+      readonly type: "provider";
       readonly backend: string;
       /** A store other than the account's default. */
       readonly name?: string;
     } & Pick<Target, "profile" | "envFile">);
 
 /** What lifecycle operations act on. */
-export type ProviderSource = Extract<StateSource, { readonly _tag: "Provider" }>;
+export type ProviderSource = Extract<StateSource, { readonly type: "provider" }>;
 
 /** A provider's state store by `--backend` name. */
 const findBackend = Effect.fn(function* (backend: string) {
@@ -68,10 +78,7 @@ export const providerContext = Effect.fn(function* (
   const auth = provider.auth
     ? yield* Contributions.resolve(provider, "auth", provider.auth)
     : Layer.empty;
-  return auth.pipe(
-    Layer.provideMerge(Layer.succeed(AuthProviders, {} satisfies AuthProviders["Service"])),
-    Layer.provideMerge(config),
-  );
+  return auth.pipe(Layer.provideMerge(AuthProvidersLive), Layer.provideMerge(config));
 });
 
 /**
@@ -82,20 +89,20 @@ export const providerContext = Effect.fn(function* (
  * them against the chosen store:
  *
  * ```ts
- * const state = yield* Alchemist.State.store({ _tag: "Local" });
+ * const state = yield* Alchemist.State.store({ type: "local" });
  * const items = yield* State.listState({ path }).pipe(
  *   Effect.provideService(State.State, Effect.succeed(state)),
  * );
  * ```
  */
 export const store = Effect.fn("Alchemist.state.store")(function* (source: StateSource) {
-  switch (source._tag) {
-    case "Local":
+  switch (source.type) {
+    case "local":
       return yield* Effect.provide(
         Effect.flatten(State.State),
         yield* Layer.build(State.localState()),
       );
-    case "Provider": {
+    case "provider": {
       const { provider, store } = yield* findBackend(source.backend);
       const { layer } = yield* store.load;
       const context = yield* Layer.build(
@@ -103,10 +110,17 @@ export const store = Effect.fn("Alchemist.state.store")(function* (source: State
       ).pipe(isolated);
       return yield* Effect.provide(Effect.flatten(State.State), context);
     }
-    case "Configured": {
+    case "configured": {
       // The configured store lives in the stack entrypoint; this is the one
       // command that can also work without one.
-      const session = yield* open(source).pipe(
+      const built = yield* importStack(source.entrypoint ?? DEFAULT_ENTRYPOINT).pipe(
+        Effect.flatMap((stack) =>
+          buildWithoutProgram(stack, {
+            stage: source.stage ?? PLACEHOLDER_STAGE,
+            profile: source.profile,
+            envFile: source.envFile,
+          }),
+        ),
         Effect.catchIf(
           (error): error is StackEntrypointError => error instanceof StackEntrypointError,
           (error) =>
@@ -117,7 +131,7 @@ export const store = Effect.fn("Alchemist.state.store")(function* (source: State
             ),
         ),
       );
-      return yield* Effect.provide(Effect.flatten(State.State), session.context);
+      return yield* Effect.provide(Effect.flatten(State.State), built.context);
     }
   }
 });
@@ -160,12 +174,55 @@ export const bootstrap = Effect.fn("Alchemist.state.bootstrap")(function* (
   );
 });
 
+/**
+ * Provision (or upgrade) the store a project's entrypoint configures, with
+ * every option it sets, such as a custom name, a pinned account or a domain.
+ */
+export const bootstrapConfigured = Effect.fn("Alchemist.state.bootstrapConfigured")(function* (
+  source: Extract<StateSource, { readonly type: "configured" }>,
+) {
+  const built = yield* importStack(source.entrypoint ?? DEFAULT_ENTRYPOINT).pipe(
+    Effect.flatMap((stack) =>
+      buildWithoutProgram(stack, {
+        stage: source.stage ?? PLACEHOLDER_STAGE,
+        profile: source.profile,
+        envFile: source.envFile,
+        updateStateStore: true,
+      }),
+    ),
+  );
+  const store = yield* Effect.provide(Effect.flatten(State.State), built.context);
+  return { version: yield* store.getVersion() };
+});
+
 /** Delete a state store and its backing resources. */
 export const teardown = Effect.fn("Alchemist.state.teardown")(function* (source: ProviderSource) {
   const { run, context } = yield* lifecycleOperation(source, "teardown");
   return yield* run({ name: source.name }).pipe(Effect.provide(context), isolated);
 });
 
+/**
+ * Move stages into a state store from the one it replaces, or back. The
+ * configured source migrates exactly the store the project's entrypoint
+ * configures, options included.
+ */
+export const migrate = Effect.fn("Alchemist.state.migrate")(function* (
+  source: StateSource,
+  request: State.StateMigrationRequest = {},
+) {
+  return yield* Effect.scoped(
+    Effect.gen(function* () {
+      const resolved = yield* store(source);
+      if (resolved.migrate === undefined) {
+        return yield* new State.StateStoreError({
+          message: `The ${source.type === "provider" ? `'${source.backend}'` : "configured"} state store does not replace another store, so it has nothing to migrate`,
+        });
+      }
+      return { stages: yield* resolved.migrate(request) };
+    }),
+  );
+});
+
 /** Past log entries from a state store, oldest first. */
 export const logs = Effect.fn("Alchemist.state.logs")(function* (
   source: ProviderSource & { readonly limit?: number; readonly since?: Date },

package/src/Alchemist/index.ts

@@ -1,21 +1,38 @@
 export * from "./Errors.ts";
-export * from "./Progress.ts";
-export { layer } from "./Runtime.ts";
+// Operations report progress as typed events: log records `onEvent` observes.
+export {
+  Event,
+  onEvent,
+  type ApplyEvent,
+  type ApplyStatus,
+  type PlanningPhase,
+  type ResourceAnnotated,
+  type ResourceStatusChanged,
+} from "../Events.ts";
+export { layer, type Services } from "./Runtime.ts";
+export {
+  apply,
+  hasChanges,
+  plan,
+  type BuildOptions,
+  type ConfigOptions,
+  type PlanOptions,
+  type PlanOutput,
+  type PlanSummary,
+  type StackPlan,
+} from "./Operations.ts";
 export {
-  routeCacheLayer,
   DEFAULT_ENTRYPOINT,
-  open,
+  importStack,
   StackEntrypointError,
-  type OpenOptions,
-  type Session,
-  type StackTarget,
   type Target,
-} from "./Session.ts";
+} from "./Entrypoint.ts";
+
+export type { ConfiguredStack } from "../Stack.ts";
 
-export * as Drift from "./routes/drift.ts";
-export * as Logs from "./routes/logs.ts";
-export * as Nuke from "./routes/nuke.ts";
-export * as Profile from "./routes/profile.ts";
-export * as Provider from "./routes/provider.ts";
-export * as Stack from "./routes/stack.ts";
-export * as State from "./routes/state.ts";
+export * as Drift from "./Drift.ts";
+export * as Logs from "./Logs.ts";
+export * as Nuke from "./Nuke.ts";
+export * as Profile from "./Profile.ts";
+export * as Provider from "./Provider.ts";
+export * as State from "./State.ts";