alchemy 2.0.0-beta.test-export-fix-4 → 2.0.0-cli-bundle-fix.1

package/bin/commands/logs.ts

@@ -0,0 +1,157 @@
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Console from "effect/Console";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
+import * as Option from "effect/Option";
+import { Command, Flag } from "effect/unstable/cli";
+
+import { findProviderByType, type LogLine } from "../../src/Provider.ts";
+import { Stage } from "../../src/Stage.ts";
+import * as State from "../../src/State/index.ts";
+import { loadConfigProvider } from "../../src/Util/ConfigProvider.ts";
+import { fileLogger } from "../../src/Util/FileLogger.ts";
+
+import { AuthProviders } from "../../src/Auth/AuthProvider.ts";
+import { withProfileOverride } from "../../src/Auth/Profile.ts";
+import {
+  envFile,
+  formatLocalTimestamp,
+  importStack,
+  main,
+  parseResourceFilter,
+  parseSince,
+  profile,
+  resourceFilter,
+  stage,
+  TAIL_COLORS,
+  TAIL_RESET,
+} from "./_shared.ts";
+
+const logsLimit = Flag.integer("limit").pipe(
+  Flag.withDescription("Number of log entries to fetch"),
+  Flag.withDefault(100),
+);
+
+const logsSince = Flag.string("since").pipe(
+  Flag.withDescription(
+    "Fetch logs since this time (e.g. '1h', '30m', '2024-01-01T00:00:00Z')",
+  ),
+  Flag.optional,
+  Flag.map(Option.getOrUndefined),
+);
+
+export const logsCommand = Command.make(
+  "logs",
+  {
+    main,
+    envFile,
+    stage,
+    profile,
+    filter: resourceFilter,
+    limit: logsLimit,
+    since: logsSince,
+  },
+  Effect.fnUntraced(function* ({
+    main,
+    stage,
+    envFile,
+    profile,
+    filter,
+    limit,
+    since,
+  }) {
+    const stackEffect = yield* importStack(main);
+
+    const services = Layer.mergeAll(
+      ConfigProvider.layer(
+        withProfileOverride(yield* loadConfigProvider(envFile), profile),
+      ),
+      Layer.succeed(AuthProviders, {}),
+      Layer.succeed(Stage, stage),
+      Logger.layer([fileLogger("out")]),
+      State.localState(),
+    );
+
+    const sinceDate = since ? parseSince(since) : undefined;
+
+    yield* Effect.gen(function* () {
+      const state = yield* State.State;
+      const stack = yield* stackEffect;
+
+      yield* Effect.gen(function* () {
+        const filterSet = parseResourceFilter(filter);
+        const availableIds = [
+          ...new Set(Object.values(stack.resources).map((r) => r.LogicalId)),
+        ].sort();
+
+        if (filterSet) {
+          for (const id of filterSet) {
+            if (!availableIds.includes(id)) {
+              return yield* Effect.die(
+                new Error(
+                  `Unknown resource '${id}' in --filter. Available: ${availableIds.join(", ") || "(none)"}`,
+                ),
+              );
+            }
+          }
+        }
+
+        const fqns = Object.keys(stack.resources);
+        const allLogs: { logicalId: string; lines: LogLine[] }[] = [];
+
+        for (const fqn of fqns) {
+          const resource = stack.resources[fqn]!;
+          if (filterSet && !filterSet.has(resource.LogicalId)) continue;
+
+          const resourceState = yield* state.get({
+            stack: stack.name,
+            stage: stack.stage,
+            fqn,
+          });
+          if (!resourceState?.attr) continue;
+
+          const provider = yield* findProviderByType(resource.Type);
+          if (!provider.logs) continue;
+
+          const lines = yield* provider.logs({
+            id: resource.LogicalId,
+            instanceId: resourceState.instanceId,
+            props: resourceState.props as any,
+            output: resourceState.attr as any,
+            options: { limit, since: sinceDate },
+          });
+
+          allLogs.push({ logicalId: resource.LogicalId, lines });
+        }
+
+        if (allLogs.length === 0) {
+          if (filterSet) {
+            yield* Console.log(
+              "No resources with logs match --filter (deploy first, or selected resources may not expose logs).",
+            );
+          } else {
+            yield* Console.log(
+              "No resources with logs found. Deploy first, then run logs.",
+            );
+          }
+          return;
+        }
+
+        const merged = allLogs
+          .flatMap(({ logicalId, lines }, i) => {
+            const color = TAIL_COLORS[i % TAIL_COLORS.length]!;
+            return lines.map((line) => ({
+              ...line,
+              formatted: `${color}${formatLocalTimestamp(line.timestamp)} [${logicalId}]${TAIL_RESET} ${line.message}`,
+            }));
+          })
+          .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+
+        for (const entry of merged) {
+          yield* Console.log(entry.formatted);
+        }
+      }).pipe(Effect.provide(stack.services));
+    }).pipe(Effect.provide(services));
+  }),
+);

package/bin/commands/state.ts

@@ -0,0 +1,230 @@
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Console from "effect/Console";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+
+import { AuthProviders } from "../../src/Auth/AuthProvider.ts";
+import { withProfileOverride } from "../../src/Auth/Profile.ts";
+import { Stage } from "../../src/Stage.ts";
+import * as State from "../../src/State/index.ts";
+import { encodeState } from "../../src/State/StateEncoding.ts";
+import { loadConfigProvider } from "../../src/Util/ConfigProvider.ts";
+import { fileLogger } from "../../src/Util/FileLogger.ts";
+
+import { envFile, importStack, main, profile, stage } from "./_shared.ts";
+
+/**
+ * When set, the State service is replaced with the on-disk
+ * `LocalState` (`.alchemy/state` under the cwd) instead of whatever
+ * the stack file configures (e.g. the Cloudflare HTTP state store).
+ * Useful for inspecting orphaned local state after a partially-failed
+ * bootstrap.
+ */
+const localFlag = Flag.boolean("local").pipe(
+  Flag.withDescription("Read from local .alchemy/state instead of the stack's configured state store"),
+  Flag.withDefault(false),
+);
+
+const stackArg = Argument.string("stack").pipe(
+  Argument.withDescription("Stack name (e.g. AlchemyEffectWebsite)"),
+);
+
+const stageArg = Argument.string("stage").pipe(
+  Argument.withDescription("Stage name (e.g. dev_samgoodwin, prod)"),
+);
+
+const fqnArg = Argument.string("fqn").pipe(
+  Argument.withDescription("Fully-qualified resource name"),
+);
+
+/**
+ * Build the layer stack used by every `alchemy state ...` subcommand.
+ *
+ * The stack file is imported and evaluated so that its `state` layer
+ * (Cloudflare HTTP store, in-memory, etc.) is in scope. Pass `local`
+ * to swap the configured State for an on-disk LocalState instead.
+ */
+const withStateService = <A, E>(
+  args: {
+    main: string;
+    stage: string;
+    envFile: import("effect/Option").Option<string>;
+    profile: string;
+    local: boolean;
+  },
+  body: (state: State.StateService) => Effect.Effect<A, E, never>,
+) =>
+  Effect.gen(function* () {
+    const stackEffect = yield* importStack(args.main);
+
+    const services = Layer.mergeAll(
+      Layer.succeed(AuthProviders, {}),
+      ConfigProvider.layer(
+        withProfileOverride(yield* loadConfigProvider(args.envFile), args.profile),
+      ),
+      Logger.layer([fileLogger("out")]),
+      Layer.succeed(Stage, args.stage),
+      // When --local is set we still build the stack to get its other
+      // services, but force State to be LocalState. Without --local the
+      // stack's configured State (httpState, etc.) wins.
+      args.local ? State.localState() : Layer.empty,
+    );
+
+    return yield* Effect.gen(function* () {
+      const stack = yield* stackEffect;
+      return yield* Effect.gen(function* () {
+        const state = yield* State.State;
+        return yield* body(state);
+      }).pipe(Effect.provide(stack.services));
+    }).pipe(Effect.provide(services));
+  });
+
+const stacksCommand = Command.make(
+  "stacks",
+  { main, envFile, stage, profile, local: localFlag },
+  Effect.fnUntraced(function* (args) {
+    yield* withStateService(args, (state) =>
+      Effect.gen(function* () {
+        const stacks = yield* state.listStacks();
+        if (stacks.length === 0) {
+          yield* Console.log("(no stacks)");
+          return;
+        }
+        for (const s of [...stacks].sort()) {
+          yield* Console.log(s);
+        }
+      }),
+    );
+  }),
+);
+
+const stagesCommand = Command.make(
+  "stages",
+  { stack: stackArg, main, envFile, stage, profile, local: localFlag },
+  Effect.fnUntraced(function* ({ stack: stackName, ...rest }) {
+    yield* withStateService(rest, (state) =>
+      Effect.gen(function* () {
+        const stages = yield* state.listStages(stackName);
+        if (stages.length === 0) {
+          yield* Console.log(`(no stages in ${stackName})`);
+          return;
+        }
+        for (const s of [...stages].sort()) {
+          yield* Console.log(s);
+        }
+      }),
+    );
+  }),
+);
+
+const resourcesCommand = Command.make(
+  "resources",
+  {
+    stack: stackArg,
+    stageName: Argument.string("stage").pipe(
+      Argument.withDescription("Stage to list resources from"),
+    ),
+    main,
+    envFile,
+    stage,
+    profile,
+    local: localFlag,
+  },
+  Effect.fnUntraced(function* ({ stack: stackName, stageName, ...rest }) {
+    yield* withStateService(rest, (state) =>
+      Effect.gen(function* () {
+        const fqns = yield* state.list({ stack: stackName, stage: stageName });
+        if (fqns.length === 0) {
+          yield* Console.log(`(no resources in ${stackName}/${stageName})`);
+          return;
+        }
+        for (const f of [...fqns].sort()) {
+          yield* Console.log(f);
+        }
+      }),
+    );
+  }),
+);
+
+const getCommand = Command.make(
+  "get",
+  {
+    stack: stackArg,
+    stageName: Argument.string("stage").pipe(
+      Argument.withDescription("Stage the resource lives in"),
+    ),
+    fqn: fqnArg,
+    main,
+    envFile,
+    stage,
+    profile,
+    local: localFlag,
+  },
+  Effect.fnUntraced(function* ({ stack: stackName, stageName, fqn, ...rest }) {
+    yield* withStateService(rest, (state) =>
+      Effect.gen(function* () {
+        const value = yield* state.get({
+          stack: stackName,
+          stage: stageName,
+          fqn,
+        });
+        if (value === undefined) {
+          yield* Console.log(
+            `(not found: ${stackName}/${stageName}/${fqn})`,
+          );
+          return;
+        }
+        // encodeState produces a JSON-friendly view: redacted secrets
+        // are unwrapped into `{ __redacted__: ... }`, Resources are
+        // flattened, etc. Same shape the store persists.
+        yield* Console.log(JSON.stringify(encodeState(value), null, 2));
+      }),
+    );
+  }),
+);
+
+const treeCommand = Command.make(
+  "tree",
+  { main, envFile, stage, profile, local: localFlag },
+  Effect.fnUntraced(function* (args) {
+    yield* withStateService(args, (state) =>
+      Effect.gen(function* () {
+        const stacks = [...(yield* state.listStacks())].sort();
+        if (stacks.length === 0) {
+          yield* Console.log("(empty state store)");
+          return;
+        }
+        for (const stk of stacks) {
+          yield* Console.log(stk);
+          const stages = [...(yield* state.listStages(stk))].sort();
+          for (let i = 0; i < stages.length; i++) {
+            const stg = stages[i]!;
+            const stageBranch = i === stages.length - 1 ? "└─" : "├─";
+            yield* Console.log(`${stageBranch} ${stg}`);
+            const indent = i === stages.length - 1 ? "   " : "│  ";
+            const fqns = [
+              ...(yield* state.list({ stack: stk, stage: stg })),
+            ].sort();
+            for (let j = 0; j < fqns.length; j++) {
+              const fqn = fqns[j]!;
+              const leaf = j === fqns.length - 1 ? "└─" : "├─";
+              yield* Console.log(`${indent}${leaf} ${fqn}`);
+            }
+          }
+        }
+      }),
+    );
+  }),
+);
+
+export const stateCommand = Command.make("state", {}).pipe(
+  Command.withSubcommands([
+    stacksCommand,
+    stagesCommand,
+    resourcesCommand,
+    getCommand,
+    treeCommand,
+  ]),
+);

package/bin/commands/tail.ts

@@ -0,0 +1,138 @@
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Console from "effect/Console";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
+import * as Stream from "effect/Stream";
+import * as Command from "effect/unstable/cli/Command";
+
+import { findProviderByType, type LogLine } from "../../src/Provider.ts";
+import { Stage } from "../../src/Stage.ts";
+import * as State from "../../src/State/index.ts";
+import { loadConfigProvider } from "../../src/Util/ConfigProvider.ts";
+import { fileLogger } from "../../src/Util/FileLogger.ts";
+
+import { AuthProviders } from "../../src/Auth/AuthProvider.ts";
+import { withProfileOverride } from "../../src/Auth/Profile.ts";
+import {
+  envFile,
+  formatLocalTimestamp,
+  importStack,
+  main,
+  parseResourceFilter,
+  profile,
+  resourceFilter,
+  stage,
+  TAIL_COLORS,
+  TAIL_RESET,
+} from "./_shared.ts";
+
+export const tailCommand = Command.make(
+  "tail",
+  {
+    main,
+    envFile,
+    stage,
+    profile,
+    filter: resourceFilter,
+  },
+  Effect.fnUntraced(function* ({ main, stage, envFile, profile, filter }) {
+    const stackEffect = yield* importStack(main);
+
+    const services = Layer.mergeAll(
+      ConfigProvider.layer(
+        withProfileOverride(yield* loadConfigProvider(envFile), profile),
+      ),
+      Layer.succeed(AuthProviders, {}),
+      Layer.succeed(Stage, stage),
+      Logger.layer([fileLogger("out")]),
+      State.localState(),
+    );
+
+    yield* Effect.gen(function* () {
+      const state = yield* State.State;
+      const stack = yield* stackEffect;
+
+      yield* Effect.gen(function* () {
+        const filterSet = parseResourceFilter(filter);
+        const availableIds = [
+          ...new Set(Object.values(stack.resources).map((r) => r.LogicalId)),
+        ].sort();
+
+        if (filterSet) {
+          for (const id of filterSet) {
+            if (!availableIds.includes(id)) {
+              return yield* Effect.die(
+                new Error(
+                  `Unknown resource '${id}' in --filter. Available: ${availableIds.join(", ") || "(none)"}`,
+                ),
+              );
+            }
+          }
+        }
+
+        const fqns = Object.keys(stack.resources);
+        const tailable: {
+          logicalId: string;
+          stream: Stream.Stream<LogLine, any, any>;
+        }[] = [];
+
+        for (const fqn of fqns) {
+          const resource = stack.resources[fqn]!;
+          if (filterSet && !filterSet.has(resource.LogicalId)) continue;
+
+          const resourceState = yield* state.get({
+            stack: stack.name,
+            stage: stack.stage,
+            fqn,
+          });
+          if (!resourceState?.attr) continue;
+
+          const provider = yield* findProviderByType(resource.Type);
+          if (!provider.tail) continue;
+
+          tailable.push({
+            logicalId: resource.LogicalId,
+            stream: provider.tail({
+              id: resource.LogicalId,
+              instanceId: resourceState.instanceId,
+              props: resourceState.props as any,
+              output: resourceState.attr as any,
+            }),
+          });
+        }
+
+        if (tailable.length === 0) {
+          if (filterSet) {
+            yield* Console.log(
+              "No tailable resources match --filter (deploy first, or selected resources may not support tail).",
+            );
+          } else {
+            yield* Console.log(
+              "No tailable resources found. Deploy first, then run tail.",
+            );
+          }
+          return;
+        }
+
+        yield* Console.log(
+          `Tailing: ${tailable.map((t) => t.logicalId).join(", ")}`,
+        );
+
+        const taggedStreams = tailable.map(({ logicalId, stream }, i) => {
+          const color = TAIL_COLORS[i % TAIL_COLORS.length]!;
+          return stream.pipe(
+            Stream.map(({ timestamp, message }) => {
+              const ts = formatLocalTimestamp(timestamp);
+              return `${color}${ts} [${logicalId}]${TAIL_RESET} ${message}`;
+            }),
+          );
+        });
+
+        yield* Stream.mergeAll(taggedStreams, {
+          concurrency: "unbounded",
+        }).pipe(Stream.runForEach((line) => Console.log(line)));
+      }).pipe(Effect.provide(stack.services));
+    }).pipe(Effect.provide(services));
+  }),
+);

package/lib/AWS/ACM/Certificate.d.ts

@@ -0,0 +1,115 @@
+import { Region as AwsRegion } from "@distilled.cloud/aws/Region";
+import * as acm from "@distilled.cloud/aws/acm";
+import * as Provider from "../../Provider.ts";
+import { Resource } from "../../Resource.ts";
+import type { Providers } from "../Providers.ts";
+export interface CertificateProps {
+    /**
+     * Primary domain name for the certificate.
+     */
+    domainName: string;
+    /**
+     * Additional domain names to include on the certificate.
+     */
+    subjectAlternativeNames?: string[];
+    /**
+     * Validation method for the certificate request.
+     * @default "DNS"
+     */
+    validationMethod?: acm.ValidationMethod;
+    /**
+     * Route 53 hosted zone used to auto-create DNS validation records.
+     *
+     * When provided together with `validationMethod: "DNS"`, the certificate
+     * provider will upsert the validation records and wait for issuance.
+     */
+    hostedZoneId?: string;
+    /**
+     * Requested key algorithm.
+     */
+    keyAlgorithm?: acm.KeyAlgorithm;
+    /**
+     * Certificate transparency logging preference.
+     */
+    certificateTransparencyLoggingPreference?: "ENABLED" | "DISABLED" | undefined;
+    /**
+     * User-defined tags to apply to the certificate.
+     */
+    tags?: Record<string, string>;
+}
+export interface Certificate extends Resource<"AWS.ACM.Certificate", CertificateProps, {
+    /**
+     * ARN of the certificate.
+     */
+    certificateArn: string;
+    /**
+     * Primary domain name of the certificate.
+     */
+    domainName: string;
+    /**
+     * Additional subject alternative names on the certificate.
+     */
+    subjectAlternativeNames: string[];
+    /**
+     * Current ACM certificate status.
+     */
+    status: acm.CertificateStatus | undefined;
+    /**
+     * ACM-managed domain validation details, including DNS validation records.
+     */
+    domainValidationOptions: acm.DomainValidation[];
+    /**
+     * Requested validation method.
+     */
+    validationMethod: acm.ValidationMethod | undefined;
+    /**
+     * Requested key algorithm.
+     */
+    keyAlgorithm: acm.KeyAlgorithm | undefined;
+    /**
+     * Route 53 hosted zone used for automatic DNS validation, when configured.
+     */
+    hostedZoneId: string | undefined;
+    /**
+     * Current tags on the certificate.
+     */
+    tags: Record<string, string>;
+    /**
+     * Certificate issue timestamp, when issued.
+     */
+    issuedAt: Date | undefined;
+    /**
+     * Certificate expiration timestamp, when issued.
+     */
+    notAfter: Date | undefined;
+}, never, Providers> {
+}
+/**
+ * An ACM certificate for CloudFront and other AWS endpoints.
+ *
+ * `Certificate` requests an ACM certificate in `us-east-1`, which is the
+ * region required for CloudFront viewer certificates. When `hostedZoneId` is
+ * provided for DNS validation, the provider creates or updates the Route 53
+ * validation records and waits for the certificate to be issued.
+ *
+ * @section Requesting Certificates
+ * @example DNS-Validated Certificate
+ * ```typescript
+ * const cert = yield* Certificate("WebsiteCertificate", {
+ *   domainName: "www.example.com",
+ *   hostedZoneId: "Z1234567890",
+ * });
+ * ```
+ *
+ * @example Certificate With SANs
+ * ```typescript
+ * const cert = yield* Certificate("WebsiteCertificate", {
+ *   domainName: "example.com",
+ *   subjectAlternativeNames: ["www.example.com"],
+ *   hostedZoneId: "Z1234567890",
+ * });
+ * ```
+ */
+export declare const Certificate: import("../../Resource.ts").ResourceClass<Certificate>;
+export declare const CertificateProvider: () => import("effect/Layer").Layer<Provider.Provider<Certificate>, never, import("effect/unstable/http/HttpClient").HttpClient | import("../../Stage.ts").Stage | import("../../Stack.ts").Stack | AwsRegion | import("@distilled.cloud/aws/Credentials").Credentials>;
+//# sourceMappingURL=Certificate.d.ts.map

package/lib/AWS/ACM/Certificate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Certificate.d.ts","sourceRoot":"","sources":["../../../src/AWS/ACM/Certificate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,KAAK,GAAG,MAAM,0BAA0B,CAAC;AAKhD,OAAO,KAAK,QAAQ,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAQjD,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,uBAAuB,CAAC,EAAE,MAAM,EAAE,CAAC;IACnC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,GAAG,CAAC,gBAAgB,CAAC;IACxC;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,YAAY,CAAC,EAAE,GAAG,CAAC,YAAY,CAAC;IAChC;;OAEG;IACH,wCAAwC,CAAC,EAAE,SAAS,GAAG,UAAU,GAAG,SAAS,CAAC;IAC9E;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,WAAY,SAAQ,QAAQ,CAC3C,qBAAqB,EACrB,gBAAgB,EAChB;IACE;;OAEG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,uBAAuB,EAAE,MAAM,EAAE,CAAC;IAClC;;OAEG;IACH,MAAM,EAAE,GAAG,CAAC,iBAAiB,GAAG,SAAS,CAAC;IAC1C;;OAEG;IACH,uBAAuB,EAAE,GAAG,CAAC,gBAAgB,EAAE,CAAC;IAChD;;OAEG;IACH,gBAAgB,EAAE,GAAG,CAAC,gBAAgB,GAAG,SAAS,CAAC;IACnD;;OAEG;IACH,YAAY,EAAE,GAAG,CAAC,YAAY,GAAG,SAAS,CAAC;IAC3C;;OAEG;IACH,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B;;OAEG;IACH,QAAQ,EAAE,IAAI,GAAG,SAAS,CAAC;IAC3B;;OAEG;IACH,QAAQ,EAAE,IAAI,GAAG,SAAS,CAAC;CAC5B,EACD,KAAK,EACL,SAAS,CACV;CAAG;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,WAAW,wDAA+C,CAAC;AAExE,eAAO,MAAM,mBAAmB,wQAyU7B,CAAC"}