alchemy 2.0.0-beta.17 → 2.0.0-beta.19

package/bin/alchemy.ts

@@ -7,6 +7,7 @@ import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import packageJson from "../package.json" with { type: "json" };
 import { AlchemyContextLive } from "../src/AlchemyContext.ts";
 import { inkCLI } from "../src/Cli/InkCLI.tsx";
+import { TelemetryLive } from "../src/Telemetry/Layer.ts";
 import { PlatformServices, runMain } from "../src/Util/PlatformServices.ts";
 
 import { handleCancellation } from "./commands/_shared.ts";
@@ -45,6 +46,7 @@ const services = Layer.mergeAll(
   Layer.provideMerge(AlchemyContextLive, PlatformServices),
   FetchHttpClient.layer,
   ConfigProvider.layer(ConfigProvider.fromEnv()),
+  TelemetryLive,
   inkCLI(),
 );
 

package/bin/commands/_shared.ts

@@ -11,6 +11,7 @@ import * as Flag from "effect/unstable/cli/Flag";
 
 import { AuthError } from "../../src/Auth/AuthProvider.ts";
 import type * as Stack from "../../src/Stack.ts";
+import { recordCli } from "../../src/Telemetry/Metrics.ts";
 import { PromptCancelled } from "../../src/Util/Clank.ts";
 
 export const USER = Config.string("USER").pipe(
@@ -218,6 +219,39 @@ export const parseSince = (value: string): Date => {
   return parsed;
 };
 
+/**
+ * Wraps a CLI command handler with a top-level OpenTelemetry span
+ * (`cli.<command>`) and bumps the `alchemy.cli.invocations` counter.
+ *
+ * `attrs` runs against the parsed command args and contributes
+ * additional attributes to the span (e.g. stage, profile, dry-run flag).
+ *
+ * Usage:
+ * ```ts
+ * Command.make(
+ *   "deploy",
+ *   { ...flags },
+ *   instrumentCommand("deploy", (a) => ({
+ *     "alchemy.stage": a.stage,
+ *     "alchemy.profile": a.profile,
+ *   }))(execStack),
+ * );
+ * ```
+ */
+export const instrumentCommand =
+  <Args>(
+    command: string,
+    attrs: (args: Args) => Record<string, unknown> = () => ({}),
+  ) =>
+  <A, E, R>(
+    handler: (args: Args) => Effect.Effect<A, E, R>,
+  ): ((args: Args) => Effect.Effect<A, E, R>) =>
+  (args) =>
+    handler(args).pipe(
+      Effect.withSpan(`cli.${command}`, { attributes: attrs(args) }),
+      recordCli(command),
+    );
+
 export const importStack = Effect.fn(function* (main: string) {
   const path = yield* Path.Path;
   const module = yield* Effect.promise(

package/bin/commands/bootstrap.ts

@@ -21,7 +21,7 @@ import * as AWSRegion from "../../src/AWS/Region.ts";
 import { loadConfigProvider } from "../../src/Util/ConfigProvider.ts";
 import { fileLogger } from "../../src/Util/FileLogger.ts";
 
-import { envFile } from "./_shared.ts";
+import { envFile, instrumentCommand } from "./_shared.ts";
 
 const awsProfile = Flag.string("profile").pipe(
   Flag.withDescription("AWS profile to use for credentials"),
@@ -50,7 +50,14 @@ export const bootstrapCommand = Command.make(
     region: awsRegion,
     destroy: bootstrapDestroy,
   },
-  Effect.fnUntraced(function* ({ envFile, profile, region, destroy }) {
+  instrumentCommand(
+    "bootstrap",
+    (a: { profile: string; region: string | undefined; destroy: boolean }) => ({
+      "alchemy.profile": a.profile,
+      "alchemy.region": a.region ?? "",
+      "alchemy.destroy": a.destroy,
+    }),
+  )(Effect.fnUntraced(function* ({ envFile, profile, region, destroy }) {
     const logger = Logger.layer([fileLogger("bootstrap.txt")]);
 
     return yield* Effect.gen(function* () {
@@ -113,5 +120,5 @@ export const bootstrapCommand = Command.make(
         );
       });
     }).pipe(Effect.provide(logger));
-  }),
+  })),
 );

package/bin/commands/deploy.ts

@@ -21,12 +21,30 @@ import {
   envFile,
   force,
   importStack,
+  instrumentCommand,
   main,
   profile,
   stage,
   yes,
 } from "./_shared.ts";
 
+const stackSpanAttrs = (args: {
+  main: string;
+  stage: string;
+  profile: string;
+  dryRun?: boolean;
+  force?: boolean;
+  yes?: boolean;
+  destroy?: boolean;
+}) => ({
+  "alchemy.stage": args.stage,
+  "alchemy.profile": args.profile,
+  "alchemy.main": args.main,
+  "alchemy.dry_run": !!args.dryRun,
+  "alchemy.force": !!args.force,
+  "alchemy.destroy": !!args.destroy,
+});
+
 const execStack = Effect.fn(function* ({
   main,
   stage,
@@ -118,7 +136,7 @@ export const deployCommand = Command.make(
     yes,
     profile,
   },
-  execStack,
+  instrumentCommand("deploy", stackSpanAttrs)(execStack),
 );
 
 export const destroyCommand = Command.make(
@@ -131,11 +149,12 @@ export const destroyCommand = Command.make(
     yes,
     profile,
   },
-  (args) =>
+  instrumentCommand("destroy", stackSpanAttrs)((args) =>
     execStack({
       ...args,
       destroy: true,
     }),
+  ),
 );
 
 export const planCommand = Command.make(
@@ -146,10 +165,11 @@ export const planCommand = Command.make(
     stage,
     profile,
   },
-  (args) =>
+  instrumentCommand("plan", stackSpanAttrs)((args) =>
     execStack({
       ...args,
       // plan is the same as deploy with dryRun always set to true
       dryRun: true,
     }),
+  ),
 );

package/bin/commands/login.ts

@@ -18,7 +18,14 @@ import * as State from "../../src/State/index.ts";
 import { loadConfigProvider } from "../../src/Util/ConfigProvider.ts";
 import { fileLogger } from "../../src/Util/FileLogger.ts";
 
-import { envFile, importStack, main, profile, stage } from "./_shared.ts";
+import {
+  envFile,
+  importStack,
+  instrumentCommand,
+  main,
+  profile,
+  stage,
+} from "./_shared.ts";
 
 const loginConfigure = Flag.boolean("configure").pipe(
   Flag.withDescription(
@@ -36,7 +43,15 @@ export const loginCommand = Command.make(
     profile,
     configure: loginConfigure,
   },
-  Effect.fnUntraced(function* ({ main, stage, envFile, profile, configure }) {
+  instrumentCommand(
+    "login",
+    (a: { main: string; stage: string; profile: string; configure: boolean }) => ({
+      "alchemy.stage": a.stage,
+      "alchemy.profile": a.profile,
+      "alchemy.main": a.main,
+      "alchemy.configure": a.configure,
+    }),
+  )(Effect.fnUntraced(function* ({ main, stage, envFile, profile, configure }) {
     const stackEffect = yield* importStack(main);
 
     const authProviders: AuthProviders["Service"] = {};
@@ -92,5 +107,5 @@ export const loginCommand = Command.make(
         { discard: true },
       );
     }).pipe(Effect.provide(services));
-  }),
+  })),
 );

package/bin/commands/logs.ts

@@ -18,6 +18,7 @@ import {
   envFile,
   formatLocalTimestamp,
   importStack,
+  instrumentCommand,
   main,
   parseResourceFilter,
   parseSince,
@@ -52,7 +53,15 @@ export const logsCommand = Command.make(
     limit: logsLimit,
     since: logsSince,
   },
-  Effect.fnUntraced(function* ({
+  instrumentCommand(
+    "logs",
+    (a: { main: string; stage: string; profile: string; limit: number }) => ({
+      "alchemy.stage": a.stage,
+      "alchemy.profile": a.profile,
+      "alchemy.main": a.main,
+      "alchemy.limit": a.limit,
+    }),
+  )(Effect.fnUntraced(function* ({
     main,
     stage,
     envFile,
@@ -153,5 +162,5 @@ export const logsCommand = Command.make(
         }
       }).pipe(Effect.provide(stack.services));
     }).pipe(Effect.provide(services));
-  }),
+  })),
 );

package/bin/commands/profile.ts

@@ -18,12 +18,15 @@ import { CloudflareAuth } from "../../src/Cloudflare/Auth/AuthProvider.ts";
 import { loadConfigProvider } from "../../src/Util/ConfigProvider.ts";
 import { fileLogger } from "../../src/Util/FileLogger.ts";
 
-import { envFile, profile } from "./_shared.ts";
+import { envFile, instrumentCommand, profile } from "./_shared.ts";
 
 const showCommand = Command.make(
   "show",
   { profile, envFile },
-  Effect.fnUntraced(function* ({ profile, envFile }) {
+  instrumentCommand(
+    "profile.show",
+    (a: { profile: string }) => ({ "alchemy.profile": a.profile }),
+  )(Effect.fnUntraced(function* ({ profile, envFile }) {
     const stored = yield* getProfile(profile);
     if (stored == null) {
       const config = yield* readConfig;
@@ -80,13 +83,16 @@ const showCommand = Command.make(
         yield* provider.prettyPrint(profile, cfg);
       }
     }).pipe(Effect.provide(services));
-  }),
+  })),
 );
 
 const clearCommand = Command.make(
   "clear",
   { profile },
-  Effect.fnUntraced(function* ({ profile }) {
+  instrumentCommand(
+    "profile.clear",
+    (a: { profile: string }) => ({ "alchemy.profile": a.profile }),
+  )(Effect.fnUntraced(function* ({ profile }) {
     const removed = yield* deleteProfile(profile);
     yield* deleteProfileCredentials(profile);
     if (removed) {
@@ -98,7 +104,7 @@ const clearCommand = Command.make(
         `Profile '${profile}' not found in profiles.json; removed any stray credentials directory.`,
       );
     }
-  }),
+  })),
 );
 
 export const profileCommand = Command.make("profile", {}).pipe(

package/bin/commands/state.ts

@@ -15,7 +15,15 @@ import * as Clank from "../../src/Util/Clank.ts";
 import { loadConfigProvider } from "../../src/Util/ConfigProvider.ts";
 import { fileLogger } from "../../src/Util/FileLogger.ts";
 
-import { envFile, importStack, main, profile, stage, yes } from "./_shared.ts";
+import {
+  envFile,
+  importStack,
+  instrumentCommand,
+  main,
+  profile,
+  stage,
+  yes,
+} from "./_shared.ts";
 
 /**
  * When set, the State service is replaced with the on-disk
@@ -91,7 +99,7 @@ const withStateService = <A, E>(
 const stacksCommand = Command.make(
   "stacks",
   { main, envFile, stage, profile, local: localFlag },
-  Effect.fnUntraced(function* (args) {
+  instrumentCommand("state.stacks")(Effect.fnUntraced(function* (args) {
     yield* withStateService(args, (state) =>
       Effect.gen(function* () {
         const stacks = yield* state.listStacks();
@@ -104,13 +112,13 @@ const stacksCommand = Command.make(
         }
       }),
     );
-  }),
+  })),
 );
 
 const stagesCommand = Command.make(
   "stages",
   { stack: stackArg, main, envFile, stage, profile, local: localFlag },
-  Effect.fnUntraced(function* ({ stack: stackName, ...rest }) {
+  instrumentCommand("state.stages")(Effect.fnUntraced(function* ({ stack: stackName, ...rest }) {
     yield* withStateService(rest, (state) =>
       Effect.gen(function* () {
         const stages = yield* state.listStages(stackName);
@@ -123,7 +131,7 @@ const stagesCommand = Command.make(
         }
       }),
     );
-  }),
+  })),
 );
 
 const resourcesCommand = Command.make(
@@ -139,7 +147,7 @@ const resourcesCommand = Command.make(
     profile,
     local: localFlag,
   },
-  Effect.fnUntraced(function* ({ stack: stackName, stageName, ...rest }) {
+  instrumentCommand("state.resources")(Effect.fnUntraced(function* ({ stack: stackName, stageName, ...rest }) {
     yield* withStateService(rest, (state) =>
       Effect.gen(function* () {
         const fqns = yield* state.list({ stack: stackName, stage: stageName });
@@ -152,7 +160,7 @@ const resourcesCommand = Command.make(
         }
       }),
     );
-  }),
+  })),
 );
 
 const getCommand = Command.make(
@@ -169,7 +177,7 @@ const getCommand = Command.make(
     profile,
     local: localFlag,
   },
-  Effect.fnUntraced(function* ({ stack: stackName, stageName, fqn, ...rest }) {
+  instrumentCommand("state.get")(Effect.fnUntraced(function* ({ stack: stackName, stageName, fqn, ...rest }) {
     yield* withStateService(rest, (state) =>
       Effect.gen(function* () {
         const value = yield* state.get({
@@ -187,13 +195,13 @@ const getCommand = Command.make(
         yield* Console.log(JSON.stringify(encodeState(value), null, 2));
       }),
     );
-  }),
+  })),
 );
 
 const treeCommand = Command.make(
   "tree",
   { main, envFile, stage, profile, local: localFlag },
-  Effect.fnUntraced(function* (args) {
+  instrumentCommand("state.tree")(Effect.fnUntraced(function* (args) {
     yield* withStateService(args, (state) =>
       Effect.gen(function* () {
         const stacks = [...(yield* state.listStacks())].sort();
@@ -221,7 +229,7 @@ const treeCommand = Command.make(
         }
       }),
     );
-  }),
+  })),
 );
 
 const clearStackArg = Argument.string("stack").pipe(
@@ -255,7 +263,7 @@ const clearCommand = Command.make(
     local: localFlag,
     yes,
   },
-  Effect.fnUntraced(function* ({ stack: stackOpt, stageName: stageOpt, yes: yesFlag, ...rest }) {
+  instrumentCommand("state.clear")(Effect.fnUntraced(function* ({ stack: stackOpt, stageName: stageOpt, yes: yesFlag, ...rest }) {
     const stackName = Option.getOrUndefined(stackOpt);
     const stageName = Option.getOrUndefined(stageOpt);
 
@@ -308,7 +316,7 @@ const clearCommand = Command.make(
         }
       }),
     );
-  }),
+  })),
 );
 
 export const stateCommand = Command.make("state", {}).pipe(

package/bin/commands/tail.ts

@@ -18,6 +18,7 @@ import {
   envFile,
   formatLocalTimestamp,
   importStack,
+  instrumentCommand,
   main,
   parseResourceFilter,
   profile,
@@ -36,7 +37,14 @@ export const tailCommand = Command.make(
     profile,
     filter: resourceFilter,
   },
-  Effect.fnUntraced(function* ({ main, stage, envFile, profile, filter }) {
+  instrumentCommand(
+    "tail",
+    (a: { main: string; stage: string; profile: string }) => ({
+      "alchemy.stage": a.stage,
+      "alchemy.profile": a.profile,
+      "alchemy.main": a.main,
+    }),
+  )(Effect.fnUntraced(function* ({ main, stage, envFile, profile, filter }) {
     const stackEffect = yield* importStack(main);
 
     const services = Layer.mergeAll(
@@ -134,5 +142,5 @@ export const tailCommand = Command.make(
         }).pipe(Stream.runForEach((line) => Console.log(line)));
       }).pipe(Effect.provide(stack.services));
     }).pipe(Effect.provide(services));
-  }),
+  })),
 );

package/lib/AWS/CloudFront/CachePolicy.d.ts

@@ -0,0 +1,106 @@
+import * as cloudfront from "@distilled.cloud/aws/cloudfront";
+import * as Provider from "../../Provider.ts";
+import { Resource } from "../../Resource.ts";
+import type { Providers } from "../Providers.ts";
+export interface CachePolicyProps {
+    /**
+     * Name of the cache policy. If omitted, a deterministic name is generated.
+     *
+     * Names must be unique per AWS account. Changing the name triggers
+     * a replacement.
+     */
+    name?: string;
+    /**
+     * Optional comment describing the policy.
+     */
+    comment?: string;
+    /**
+     * Minimum amount of time, in seconds, that objects stay in the cache.
+     */
+    minTTL: number;
+    /**
+     * Default amount of time, in seconds, that objects stay in the cache when
+     * the origin does not send `Cache-Control` or `Expires` headers.
+     */
+    defaultTTL?: number;
+    /**
+     * Maximum amount of time, in seconds, that objects stay in the cache.
+     */
+    maxTTL?: number;
+    /**
+     * Controls which request values become part of the cache key and which
+     * additional headers/cookies/query strings CloudFront forwards to the origin.
+     */
+    parametersInCacheKeyAndForwardedToOrigin?: cloudfront.ParametersInCacheKeyAndForwardedToOrigin;
+}
+export interface CachePolicy extends Resource<"AWS.CloudFront.CachePolicy", CachePolicyProps, {
+    /**
+     * CloudFront-assigned cache policy identifier.
+     */
+    cachePolicyId: string;
+    /**
+     * Name of the cache policy.
+     */
+    name: string;
+    /**
+     * Most recent entity tag for update/delete operations.
+     */
+    etag: string | undefined;
+    /**
+     * Current comment on the policy.
+     */
+    comment: string | undefined;
+    /**
+     * Current minimum TTL.
+     */
+    minTTL: number;
+    /**
+     * Current default TTL.
+     */
+    defaultTTL: number | undefined;
+    /**
+     * Current maximum TTL.
+     */
+    maxTTL: number | undefined;
+    /**
+     * Current cache-key/forwarded-value configuration.
+     */
+    parametersInCacheKeyAndForwardedToOrigin: cloudfront.ParametersInCacheKeyAndForwardedToOrigin | undefined;
+}, never, Providers> {
+}
+/**
+ * A CloudFront cache policy.
+ *
+ * Cache policies determine the values CloudFront includes in the cache key,
+ * the headers, cookies and query strings it forwards to the origin, and the
+ * TTL bounds for cached responses. Policies are referenced by ID on a
+ * Distribution's default behavior or per-path cache behaviors.
+ *
+ * For AWS-managed policies (CachingOptimized, CachingDisabled,
+ * AllViewerExceptHostHeader) reference them by ID via the constants in
+ * {@link ManagedPolicies} instead of creating a custom policy.
+ *
+ * @section Creating Cache Policies
+ * @example Cache by query string and Authorization header
+ * ```typescript
+ * const cachePolicy = yield* CachePolicy("ApiCachePolicy", {
+ *   comment: "Cache GETs by query string + Authorization",
+ *   minTTL: 0,
+ *   defaultTTL: 60,
+ *   maxTTL: 3600,
+ *   parametersInCacheKeyAndForwardedToOrigin: {
+ *     EnableAcceptEncodingGzip: true,
+ *     EnableAcceptEncodingBrotli: true,
+ *     HeadersConfig: {
+ *       HeaderBehavior: "whitelist",
+ *       Headers: { Quantity: 1, Items: ["Authorization"] },
+ *     },
+ *     CookiesConfig: { CookieBehavior: "none" },
+ *     QueryStringsConfig: { QueryStringBehavior: "all" },
+ *   },
+ * });
+ * ```
+ */
+export declare const CachePolicy: import("../../Resource.ts").ResourceClass<CachePolicy>;
+export declare const CachePolicyProvider: () => import("effect/Layer").Layer<Provider.Provider<CachePolicy>, never, import("effect/unstable/http/HttpClient").HttpClient | import("../../Stage.ts").Stage | import("../../Stack.ts").Stack | import("@distilled.cloud/aws/Region").Region | import("@distilled.cloud/aws/Credentials").Credentials>;
+//# sourceMappingURL=CachePolicy.d.ts.map

package/lib/AWS/CloudFront/CachePolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CachePolicy.d.ts","sourceRoot":"","sources":["../../../src/AWS/CloudFront/CachePolicy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,iCAAiC,CAAC;AAI9D,OAAO,KAAK,QAAQ,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,MAAM,WAAW,gBAAgB;IAC/B;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,wCAAwC,CAAC,EAAE,UAAU,CAAC,wCAAwC,CAAC;CAChG;AAED,MAAM,WAAW,WAAY,SAAQ,QAAQ,CAC3C,4BAA4B,EAC5B,gBAAgB,EAChB;IACE;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB;;OAEG;IACH,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B;;OAEG;IACH,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B;;OAEG;IACH,wCAAwC,EACpC,UAAU,CAAC,wCAAwC,GACnD,SAAS,CAAC;CACf,EACD,KAAK,EACL,SAAS,CACV;CAAG;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,WAAW,wDAAsD,CAAC;AAE/E,eAAO,MAAM,mBAAmB,2SAmJ7B,CAAC"}

package/lib/AWS/CloudFront/CachePolicy.js

@@ -0,0 +1,147 @@
+import * as cloudfront from "@distilled.cloud/aws/cloudfront";
+import * as Effect from "effect/Effect";
+import { isResolved } from "../../Diff.js";
+import { createPhysicalName } from "../../PhysicalName.js";
+import * as Provider from "../../Provider.js";
+import { Resource } from "../../Resource.js";
+/**
+ * A CloudFront cache policy.
+ *
+ * Cache policies determine the values CloudFront includes in the cache key,
+ * the headers, cookies and query strings it forwards to the origin, and the
+ * TTL bounds for cached responses. Policies are referenced by ID on a
+ * Distribution's default behavior or per-path cache behaviors.
+ *
+ * For AWS-managed policies (CachingOptimized, CachingDisabled,
+ * AllViewerExceptHostHeader) reference them by ID via the constants in
+ * {@link ManagedPolicies} instead of creating a custom policy.
+ *
+ * @section Creating Cache Policies
+ * @example Cache by query string and Authorization header
+ * ```typescript
+ * const cachePolicy = yield* CachePolicy("ApiCachePolicy", {
+ *   comment: "Cache GETs by query string + Authorization",
+ *   minTTL: 0,
+ *   defaultTTL: 60,
+ *   maxTTL: 3600,
+ *   parametersInCacheKeyAndForwardedToOrigin: {
+ *     EnableAcceptEncodingGzip: true,
+ *     EnableAcceptEncodingBrotli: true,
+ *     HeadersConfig: {
+ *       HeaderBehavior: "whitelist",
+ *       Headers: { Quantity: 1, Items: ["Authorization"] },
+ *     },
+ *     CookiesConfig: { CookieBehavior: "none" },
+ *     QueryStringsConfig: { QueryStringBehavior: "all" },
+ *   },
+ * });
+ * ```
+ */
+export const CachePolicy = Resource("AWS.CloudFront.CachePolicy");
+export const CachePolicyProvider = () => Provider.effect(CachePolicy, Effect.gen(function* () {
+    const getById = Effect.fn(function* (id) {
+        const config = yield* cloudfront
+            .getCachePolicyConfig({ Id: id })
+            .pipe(Effect.catchTag("NoSuchCachePolicy", () => Effect.succeed(undefined)));
+        if (!config?.CachePolicyConfig)
+            return undefined;
+        return { config: config.CachePolicyConfig, etag: config.ETag };
+    });
+    const getByName = Effect.fn(function* (name) {
+        const listed = yield* cloudfront.listCachePolicies({ Type: "custom" });
+        const summary = listed.CachePolicyList?.Items?.find((item) => item.CachePolicy?.CachePolicyConfig?.Name === name);
+        if (!summary?.CachePolicy?.Id)
+            return undefined;
+        return yield* getById(summary.CachePolicy.Id).pipe(Effect.map((found) => found ? { id: summary.CachePolicy.Id, ...found } : undefined));
+    });
+    const buildConfig = (name, props) => ({
+        Name: name,
+        Comment: props.comment,
+        MinTTL: props.minTTL,
+        DefaultTTL: props.defaultTTL,
+        MaxTTL: props.maxTTL,
+        ParametersInCacheKeyAndForwardedToOrigin: props.parametersInCacheKeyAndForwardedToOrigin,
+    });
+    const toAttrs = (id, config, etag) => ({
+        cachePolicyId: id,
+        name: config.Name,
+        etag,
+        comment: config.Comment,
+        minTTL: config.MinTTL,
+        defaultTTL: config.DefaultTTL,
+        maxTTL: config.MaxTTL,
+        parametersInCacheKeyAndForwardedToOrigin: config.ParametersInCacheKeyAndForwardedToOrigin,
+    });
+    return {
+        stables: ["cachePolicyId"],
+        diff: Effect.fn(function* ({ id, news, olds }) {
+            if (!isResolved(news))
+                return undefined;
+            if ((yield* createName(id, olds ?? {})) !==
+                (yield* createName(id, news))) {
+                return { action: "replace" };
+            }
+        }),
+        read: Effect.fn(function* ({ id, olds, output }) {
+            if (output?.cachePolicyId) {
+                const found = yield* getById(output.cachePolicyId);
+                if (found)
+                    return toAttrs(output.cachePolicyId, found.config, found.etag);
+            }
+            const name = yield* createName(id, olds ?? {});
+            const found = yield* getByName(name);
+            if (!found)
+                return undefined;
+            return toAttrs(found.id, found.config, found.etag);
+        }),
+        create: Effect.fn(function* ({ id, news, session }) {
+            const name = yield* createName(id, news);
+            const created = yield* cloudfront
+                .createCachePolicy({ CachePolicyConfig: buildConfig(name, news) })
+                .pipe(Effect.catchTag("CachePolicyAlreadyExists", () => getByName(name).pipe(Effect.flatMap((existing) => existing
+                ? Effect.succeed({
+                    CachePolicy: {
+                        Id: existing.id,
+                        LastModifiedTime: new Date(),
+                        CachePolicyConfig: existing.config,
+                    },
+                    ETag: existing.etag,
+                    Location: undefined,
+                })
+                : Effect.fail(new Error(`Cache policy '${name}' already exists but could not be recovered`))))));
+            if (!created.CachePolicy?.Id) {
+                return yield* Effect.fail(new Error("createCachePolicy returned no identifier"));
+            }
+            yield* session.note(created.CachePolicy.Id);
+            return toAttrs(created.CachePolicy.Id, created.CachePolicy.CachePolicyConfig, created.ETag);
+        }),
+        update: Effect.fn(function* ({ news, output, session }) {
+            const current = yield* getById(output.cachePolicyId);
+            const updated = yield* cloudfront.updateCachePolicy({
+                Id: output.cachePolicyId,
+                IfMatch: current?.etag ?? output.etag,
+                CachePolicyConfig: buildConfig(output.name, news),
+            });
+            if (!updated.CachePolicy?.Id) {
+                return yield* Effect.fail(new Error("updateCachePolicy returned no identifier"));
+            }
+            yield* session.note(output.cachePolicyId);
+            return toAttrs(updated.CachePolicy.Id, updated.CachePolicy.CachePolicyConfig, updated.ETag);
+        }),
+        delete: Effect.fn(function* ({ output }) {
+            const current = yield* getById(output.cachePolicyId);
+            if (!current)
+                return;
+            yield* cloudfront
+                .deleteCachePolicy({
+                Id: output.cachePolicyId,
+                IfMatch: current.etag,
+            })
+                .pipe(Effect.catchTag("NoSuchCachePolicy", () => Effect.void));
+        }),
+    };
+}));
+const createName = (id, props) => props.name
+    ? Effect.succeed(props.name)
+    : createPhysicalName({ id, maxLength: 128, lowercase: true });
+//# sourceMappingURL=CachePolicy.js.map