alchemy-effect 0.1.0 → 0.3.0

package/src/stage.ts

@@ -0,0 +1,85 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import type { StackName, StackRef, Stack, StackResources } from "./stack.ts";
+import { ref } from "./ref.ts";
+
+export interface StageConfig {
+  /**
+   * Whether to retain the stage when destroying the stack.
+   *
+   * @default - true if the current stage starts with "prod"
+   */
+  retain?: boolean;
+
+  /**
+   * Whether to adopt resources that already exist during the created phase.
+   *
+   * @default false
+   */
+  adopt?: boolean;
+}
+
+export class Stage extends Context.Tag("Stage")<Stage, string>() {}
+
+export type Stages<Req = never, Err = never> = {
+  config: (stage: string) => StageConfig | Effect.Effect<StageConfig, Err, Req>;
+  ref<S extends Stack>(name: StackName<S>): StackRefs<S>;
+};
+
+export const defineStages = <Req = never, Err = never>(
+  config: (stage: string) => StageConfig | Effect.Effect<StageConfig, Err, Req>,
+): Stages<Req, Err> => ({
+  config,
+  ref: <S extends Stack>(stack: StackName<NoInfer<S>>): StackRefs<S> => {
+    const proxy = (get: (id: string) => any) =>
+      new Proxy({}, { get: (_, id: string) => get(id) });
+    const proxyStage = (stage: string) =>
+      proxy((resourceId: string) =>
+        ref({
+          stack,
+          stage,
+          resourceId,
+        }),
+      );
+    return proxy((stage) =>
+      stage == "as"
+        ? (builders: StackRefBuilders) =>
+            proxy((stage: string) => {
+              if (stage in builders) {
+                const builder = builders[stage as keyof typeof builders];
+                return typeof builder === "string"
+                  ? proxyStage(stage)
+                  : (...args: any[]) => proxyStage(builder(...args));
+              }
+              return proxyStage(stage);
+            })
+        : proxy((resourceId: string) =>
+            ref({
+              stack,
+              stage,
+              resourceId,
+            }),
+          ),
+    ) as StackRefs<S>;
+  },
+});
+
+export interface StackRefBuilders {
+  [stage: string]: string | ((...args: any[]) => string);
+}
+
+export type StackRefs<S extends Stack> = {
+  [stage in string]: StackRef<StackResources<S>>;
+} & {
+  as<Builders extends StackRefBuilders>(
+    stages?: Builders,
+  ): {
+    [stage in Exclude<string, keyof Builders>]: StackRef<StackResources<S>>;
+  } & {
+    [builder in keyof Builders]: Builders[builder] extends string
+      ? StackRef<StackResources<S>>
+      : Builders[builder] extends (...args: infer Args) => any
+        ? (...args: Args) => StackRef<StackResources<S>>
+        : never;
+  };
+};

package/src/state.ts

@@ -1,11 +1,10 @@
-import { FileSystem } from "@effect/platform";
 import type { PlatformError } from "@effect/platform/Error";
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Path from "@effect/platform/Path";
 import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import path from "node:path";
-import { App } from "./app.ts";
 import type { BindNode } from "./plan.ts";
 import { isResource } from "./resource.ts";
 
@@ -75,18 +74,29 @@ export class StateStoreError extends Data.TaggedError("StateStoreError")<{
 }> {}
 
 export interface StateService {
-  listApps(): Effect.Effect<string[], StateStoreError, never>;
-  listStages(appName?: string): Effect.Effect<string[], StateStoreError, never>;
+  listStacks(): Effect.Effect<string[], StateStoreError, never>;
+  listStages(stack: string): Effect.Effect<string[], StateStoreError, never>;
   // stub
-  get(
-    id: string,
-  ): Effect.Effect<ResourceState | undefined, StateStoreError, never>;
-  set<V extends ResourceState>(
-    id: string,
-    value: V,
-  ): Effect.Effect<V, StateStoreError, never>;
-  delete(id: string): Effect.Effect<void, StateStoreError, never>;
-  list(): Effect.Effect<string[], StateStoreError, never>;
+  get(request: {
+    stack: string;
+    stage: string;
+    resourceId: string;
+  }): Effect.Effect<ResourceState | undefined, StateStoreError, never>;
+  set<V extends ResourceState>(request: {
+    stack: string;
+    stage: string;
+    resourceId: string;
+    value: V;
+  }): Effect.Effect<V, StateStoreError, never>;
+  delete(request: {
+    stack: string;
+    stage: string;
+    resourceId: string;
+  }): Effect.Effect<void, StateStoreError, never>;
+  list(request: {
+    stack: string;
+    stage: string;
+  }): Effect.Effect<string[], StateStoreError, never>;
 }
 
 export class State extends Context.Tag("AWS::Lambda::State")<
@@ -97,13 +107,12 @@ export class State extends Context.Tag("AWS::Lambda::State")<
 // TODO(sam): implement with SQLite3
 export const localFs = Layer.effect(
   State,
+  // @ts-expect-error -
   Effect.gen(function* () {
-    const app = yield* App;
     const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
     const dotAlchemy = path.join(process.cwd(), ".alchemy");
     const stateDir = path.join(dotAlchemy, "state");
-    const appDir = path.join(stateDir, app.name);
-    const stageDir = path.join(appDir, app.stage);
 
     const fail = (err: PlatformError) =>
       Effect.fail(
@@ -120,9 +129,22 @@ export const localFs = Layer.effect(
         Effect.catchTag("BadArgument", (e) => fail(e)),
       );
 
-    const resourceFile = (id: string) => path.join(stageDir, `${id}.json`);
+    const stage = ({ stack, stage }: { stack: string; stage: string }) =>
+      path.join(stateDir, stack, stage);
 
-    yield* fs.makeDirectory(stageDir, { recursive: true });
+    const resource = ({
+      stack,
+      stage,
+      resourceId,
+    }: {
+      stack: string;
+      stage: string;
+      resourceId: string;
+    }) => path.join(stateDir, stack, stage, `${resourceId}.json`);
+
+    const ensure = yield* Effect.cachedFunction((dir: string) =>
+      fs.makeDirectory(dir, { recursive: true }),
+    );
 
     return {
       listApps: () =>
@@ -130,43 +152,44 @@ export const localFs = Layer.effect(
           recover,
           Effect.map((files) => files ?? []),
         ),
-      listStages: (appName: string = app.name) =>
-        fs.readDirectory(path.join(stateDir, appName)).pipe(
+      listStages: (stack: string) =>
+        fs.readDirectory(path.join(stateDir, stack)).pipe(
           recover,
           Effect.map((files) => files ?? []),
         ),
-      get: (id) =>
-        fs.readFile(resourceFile(id)).pipe(
+      get: (request) =>
+        fs.readFile(resource(request)).pipe(
           Effect.map((file) => JSON.parse(file.toString())),
           recover,
         ),
-      set: <V extends ResourceState>(id: string, value: V) =>
-        fs
-          .writeFileString(
-            resourceFile(id),
-            JSON.stringify(
-              value,
-              (k, v) => {
-                if (isResource(v)) {
-                  return {
-                    id: v.id,
-                    type: v.type,
-                    props: v.props,
-                    attr: v.attr,
-                  };
-                }
-                return v;
-              },
-              2,
+      set: (request) =>
+        ensure(stage(request)).pipe(
+          Effect.flatMap(() =>
+            fs.writeFileString(
+              resource(request),
+              JSON.stringify(
+                request.value,
+                (k, v) => {
+                  if (isResource(v)) {
+                    return {
+                      id: v.id,
+                      type: v.type,
+                      props: v.props,
+                      attr: v.attr,
+                    };
+                  }
+                  return v;
+                },
+                2,
+              ),
             ),
-          )
-          .pipe(
-            recover,
-            Effect.map(() => value),
           ),
-      delete: (id) => fs.remove(resourceFile(id)).pipe(recover),
-      list: () =>
-        fs.readDirectory(stageDir).pipe(
+          recover,
+          Effect.map(() => request.value),
+        ),
+      delete: (request) => fs.remove(resource(request)).pipe(recover),
+      list: (request) =>
+        fs.readDirectory(stage(request)).pipe(
           recover,
           Effect.map(
             (files) => files?.map((file) => file.replace(/\.json$/, "")) ?? [],
@@ -176,21 +199,77 @@ export const localFs = Layer.effect(
   }),
 );
 
-export const inMemory = () => {
-  const state = new Map<string, any>();
-  return Layer.succeed(State, {
-    listApps: () => Effect.succeed([]),
+type StackId = string;
+type StageId = string;
+type ResourceId = string;
+
+export const inMemory = (
+  initialState: Record<
+    StackId,
+    Record<StageId, Record<ResourceId, ResourceState>>
+  > = {},
+) =>
+  Layer.succeed(State, inMemoryService(initialState)) as Layer.Layer<
+    State,
+    never,
+    never
+  >;
+
+export const inMemoryService = (
+  initialState: Record<
+    StackId,
+    Record<StageId, Record<ResourceId, ResourceState>>
+  > = {},
+) => {
+  const state = new Map<StackId, Map<StageId, Map<ResourceId, ResourceState>>>(
+    Object.entries(initialState).map(([stack, stages]) => [
+      stack,
+      new Map(
+        Object.entries(stages).map(([stage, resources]) => [
+          stage,
+          new Map(Object.entries(resources)),
+        ]),
+      ),
+    ]),
+  );
+  return {
+    listStacks: () => Effect.succeed(Array.from(state.keys())),
     // oxlint-disable-next-line require-yield
-    listStages: (_appName?: string) => Effect.succeed([]),
-    get: (id: string) => Effect.succeed(state.get(id)),
-    set: <V>(id: string, value: V) => {
-      state.set(id, value);
+    listStages: (stack: string) =>
+      Effect.succeed(Array.from(state.get(stack)?.keys() ?? [])),
+    get: ({
+      stack,
+      stage,
+      resourceId,
+    }: {
+      stack: string;
+      stage: string;
+      resourceId: string;
+    }) => Effect.succeed(state.get(stack)?.get(stage)?.get(resourceId)),
+    set: <V extends ResourceState>({
+      stack,
+      stage,
+      resourceId,
+      value,
+    }: {
+      stack: string;
+      stage: string;
+      resourceId: string;
+      value: V;
+    }) => {
+      state.get(stack)?.get(stage)?.set(resourceId, value);
       return Effect.succeed(value);
     },
-    delete: (id: string) => {
-      state.delete(id);
-      return Effect.succeed(undefined);
-    },
-    list: () => Effect.succeed(Array.from(state.keys())),
-  });
+    delete: ({
+      stack,
+      stage,
+      resourceId,
+    }: {
+      stack: string;
+      stage: string;
+      resourceId: string;
+    }) => Effect.succeed(state.get(stack)?.get(stage)?.delete(resourceId)),
+    list: ({ stack, stage }: { stack: string; stage: string }) =>
+      Effect.succeed(Array.from(state.get(stack)?.get(stage)?.keys() ?? [])),
+  };
 };

package/src/tags.ts

@@ -0,0 +1,38 @@
+import * as Effect from "effect/Effect";
+import { App } from "./app.ts";
+
+export type Tags =
+  | Record<string, string>
+  | [string, string][]
+  | { Key: string; Value: string }[];
+
+const normalizeTags = (tags: Tags) =>
+  Array.isArray(tags)
+    ? Object.fromEntries(
+        tags.map((tag) =>
+          Array.isArray(tag) ? [tag[0], tag[1]] : [tag.Key, tag.Value],
+        ),
+      )
+    : tags;
+
+export const hasTags = (expectedTags: Tags, tags: Tags | undefined) => {
+  const actualTags = normalizeTags(tags ?? []);
+  return Object.entries(normalizeTags(expectedTags)).every(
+    ([key, value]) => actualTags[key] === value,
+  );
+};
+
+export const createTagsList = (tags: Tags) =>
+  Object.entries(normalizeTags(tags)).map(([Key, Value]) => ({
+    Key,
+    Value,
+  }));
+
+export const createTagger = Effect.fn(function* () {
+  const app = yield* App;
+  return (id: string) => ({
+    "alchemy::app": app.name,
+    "alchemy::stage": app.stage,
+    "alchemy::id": id,
+  });
+});

package/src/test.ts

@@ -0,0 +1,172 @@
+import { FetchHttpClient, FileSystem, HttpClient } from "@effect/platform";
+import * as PlatformConfigProvider from "@effect/platform/PlatformConfigProvider";
+import { NodeContext } from "@effect/platform-node";
+import * as Path from "@effect/platform/Path";
+import { it, expect } from "@effect/vitest";
+import { ConfigProvider, LogLevel } from "effect";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
+import * as Scope from "effect/Scope";
+import * as App from "./app.ts";
+import { DotAlchemy, dotAlchemy } from "./dot-alchemy.ts";
+import * as State from "./state.ts";
+import type { Resource } from "./resource.ts";
+import { CLI } from "./cli/service.ts";
+
+declare module "@effect/vitest" {
+  interface ExpectStatic {
+    emptyObject(): any;
+    propExpr(identifier: string, src: Resource): any;
+  }
+}
+
+expect.emptyObject = () =>
+  expect.toSatisfy(
+    (deletions) => Object.keys(deletions).length === 0,
+    "empty object",
+  );
+
+expect.propExpr = (identifier: string, src: Resource) =>
+  expect.objectContaining({
+    kind: "PropExpr",
+    identifier,
+    expr: expect.objectContaining({
+      kind: "ResourceExpr",
+      src,
+    }),
+  });
+
+type Provided =
+  | Scope.Scope
+  | App.App
+  | State.State
+  | DotAlchemy
+  | HttpClient.HttpClient
+  | FileSystem.FileSystem
+  | Path.Path;
+
+export function test(
+  name: string,
+  options: {
+    timeout?: number;
+    state?: Layer.Layer<State.State, never, App.App>;
+  },
+  testCase: Effect.Effect<void, any, Provided>,
+): void;
+
+export function test(
+  name: string,
+  testCase: Effect.Effect<void, any, Provided>,
+): void;
+
+export function test(
+  name: string,
+  ...args:
+    | [
+        {
+          timeout?: number;
+          state?: Layer.Layer<State.State, never, App.App>;
+        },
+        Effect.Effect<void, any, Provided>,
+      ]
+    | [Effect.Effect<void, any, Provided>]
+) {
+  const [options = {}, testCase] =
+    args.length === 1 ? [undefined, args[0]] : args;
+  const platform = Layer.mergeAll(
+    NodeContext.layer,
+    FetchHttpClient.layer,
+    Logger.pretty,
+  );
+
+  const alchemy = Layer.provideMerge(
+    Layer.mergeAll(options.state ?? State.localFs, testCLI),
+    Layer.mergeAll(
+      App.make({
+        name: name.replaceAll(/[^a-zA-Z0-9_]/g, "-"),
+        stage: "test",
+        config: {
+          adopt: true,
+          aws: {
+            profile: "default",
+          },
+        },
+      }),
+      dotAlchemy,
+    ),
+  );
+
+  return it.scopedLive(
+    name,
+    () =>
+      Effect.gen(function* () {
+        const configProvider = ConfigProvider.orElse(
+          yield* PlatformConfigProvider.fromDotEnv(".env"),
+          ConfigProvider.fromEnv,
+        );
+        return yield* testCase.pipe(Effect.withConfigProvider(configProvider));
+      }).pipe(
+        Effect.provide(Layer.provideMerge(alchemy, platform)),
+        Logger.withMinimumLogLevel(
+          process.env.DEBUG ? LogLevel.Debug : LogLevel.Info,
+        ),
+        Effect.provide(NodeContext.layer),
+        Effect.provide(NodeContext.layer),
+      ),
+    options.timeout,
+  );
+}
+
+export namespace test {
+  export const state = (resources: Record<string, State.ResourceState> = {}) =>
+    Layer.effect(
+      State.State,
+      Effect.gen(function* () {
+        const app = yield* App.App;
+        return State.inMemoryService({
+          [app.name]: {
+            [app.stage]: resources,
+          },
+        });
+      }),
+    );
+
+  export const defaultState = (
+    resources: Record<string, State.ResourceState> = {},
+    other?: {
+      [stack: string]: {
+        [stage: string]: {
+          [resourceId: string]: State.ResourceState;
+        };
+      };
+    },
+  ) =>
+    Layer.succeed(
+      State.State,
+      State.inMemoryService({
+        ["test-app"]: {
+          ["test-stage"]: resources,
+        },
+        ...other,
+      }),
+    );
+}
+
+export const testCLI = Layer.succeed(
+  CLI,
+  CLI.of({
+    approvePlan: () => Effect.succeed(true),
+    displayPlan: () => Effect.void,
+    startApplySession: () =>
+      Effect.succeed({
+        done: () => Effect.void,
+        emit: (event) =>
+          Effect.log(
+            event.kind === "status-change"
+              ? `${event.status} ${event.id}(${event.type})`
+              : event.message,
+          ),
+      }),
+  }),
+);

package/src/type.ts

@@ -0,0 +1,6 @@
+export type type<T> = new () => T;
+export const type = class {} as new <T>() => T;
+
+export declare namespace type {
+  export type of<T extends type<any>> = InstanceType<T>;
+}

package/src/unknown.ts

@@ -0,0 +1,6 @@
+import { type Output, isOutput } from "./output.ts";
+import type { Input } from "./input.ts";
+
+// @ts-expect-error - we want to allow any value to be checked for unknown
+export const isUnknown = <V>(value: V): value is Output<Input.Resolve<V>> =>
+  isOutput(value);

package/src/user.ts

@@ -0,0 +1,4 @@
+import { env } from "./env.ts";
+
+export type USER = typeof USER;
+export const USER = env.USER ?? env.USERNAME ?? "unknown";

package/src/util.ts

@@ -0,0 +1,21 @@
+import * as Effect from "effect/Effect";
+
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+
+export type UnionToIntersection<U> = (
+  U extends any ? (k: U) => void : never
+) extends (k: infer I) => void
+  ? I
+  : never;
+
+export const assertDefined = <T>(value: T | undefined, message: string): T => {
+  if (!value) {
+    throw new Error(message);
+  }
+  return value;
+};
+
+export const asEffect = <T, Err = never, Req = never>(
+  effect: T | Effect.Effect<T, Err, Req>,
+): Effect.Effect<T, Err, Req> =>
+  Effect.isEffect(effect) ? effect : Effect.succeed(effect);

package/lib/approve.d.ts

@@ -1,15 +0,0 @@
-import * as Context from "effect/Context";
-import type * as Effect from "effect/Effect";
-import type { Plan } from "./plan.ts";
-declare const PlanRejected_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
-    readonly _tag: "PlanRejected";
-} & Readonly<A>;
-export declare class PlanRejected extends PlanRejected_base<{}> {
-}
-declare const PlanReviewer_base: Context.TagClass<PlanReviewer, "PlanReviewer", {
-    approve: <P extends Plan>(plan: P) => Effect.Effect<void, PlanRejected>;
-}>;
-export declare class PlanReviewer extends PlanReviewer_base {
-}
-export {};
-//# sourceMappingURL=approve.d.ts.map

package/lib/approve.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"approve.d.ts","sourceRoot":"","sources":["../src/approve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAE1C,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;;;;AAEtC,qBAAa,YAAa,SAAQ,kBAAiC,EAAE,CAAC;CAAG;;aAK5D,CAAC,CAAC,SAAS,IAAI,EAAE,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC;;AAH3E,qBAAa,YAAa,SAAQ,iBAK/B;CAAG"}

package/lib/approve.js

@@ -1,7 +0,0 @@
-import * as Context from "effect/Context";
-import * as Data from "effect/Data";
-export class PlanRejected extends Data.TaggedError("PlanRejected") {
-}
-export class PlanReviewer extends Context.Tag("PlanReviewer")() {
-}
-//# sourceMappingURL=approve.js.map

package/lib/approve.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"approve.js","sourceRoot":"","sources":["../src/approve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,IAAI,MAAM,aAAa,CAAC;AAIpC,MAAM,OAAO,YAAa,SAAQ,IAAI,CAAC,WAAW,CAAC,cAAc,CAAK;CAAG;AAEzE,MAAM,OAAO,YAAa,SAAQ,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,EAK1D;CAAG"}

package/lib/aws/lambda/function.client.d.ts

@@ -1,8 +0,0 @@
-import * as Context from "effect/Context";
-import { Lambda as LambdaClient } from "itty-aws/lambda";
-declare const FunctionClient_base: Context.TagClass<FunctionClient, "AWS::Lambda::Function.Client", LambdaClient>;
-export declare class FunctionClient extends FunctionClient_base {
-}
-export declare const client: () => import("effect/Layer").Layer<FunctionClient, never, import("../credentials.ts").Credentials | import("../region.ts").Region>;
-export {};
-//# sourceMappingURL=function.client.d.ts.map

package/lib/aws/lambda/function.client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"function.client.d.ts","sourceRoot":"","sources":["../../../src/aws/lambda/function.client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAAE,MAAM,IAAI,YAAY,EAAE,MAAM,iBAAiB,CAAC;;AAGzD,qBAAa,cAAe,SAAQ,mBAGjC;CAAG;AAEN,eAAO,MAAM,MAAM,oIAGY,CAAC"}

package/lib/aws/lambda/function.client.js

@@ -1,7 +0,0 @@
-import * as Context from "effect/Context";
-import { Lambda as LambdaClient } from "itty-aws/lambda";
-import { createAWSServiceClientLayer } from "../client.js";
-export class FunctionClient extends Context.Tag("AWS::Lambda::Function.Client")() {
-}
-export const client = createAWSServiceClientLayer(FunctionClient, LambdaClient);
-//# sourceMappingURL=function.client.js.map

package/lib/aws/lambda/function.client.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"function.client.js","sourceRoot":"","sources":["../../../src/aws/lambda/function.client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAAE,MAAM,IAAI,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,2BAA2B,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,OAAO,cAAe,SAAQ,OAAO,CAAC,GAAG,CAAC,8BAA8B,CAAC,EAG5E;CAAG;AAEN,MAAM,CAAC,MAAM,MAAM,GAAG,2BAA2B,CAG/C,cAAc,EAAE,YAAY,CAAC,CAAC"}

package/lib/aws/sqs/queue.client.d.ts

@@ -1,12 +0,0 @@
-import * as Context from "effect/Context";
-import * as Layer from "effect/Layer";
-import { SQS as SQSClient } from "itty-aws/sqs";
-import * as Credentials from "../credentials.ts";
-import * as Region from "../region.ts";
-declare const QueueClient_base: Context.TagClass<QueueClient, "AWS::SQS::Queue.Client", SQSClient>;
-export declare class QueueClient extends QueueClient_base {
-}
-export declare const client: () => Layer.Layer<QueueClient, never, Credentials.Credentials | Region.Region>;
-export declare const clientFromEnv: () => Layer.Layer<QueueClient, Region.EnvironmentVariableNotSet, never>;
-export {};
-//# sourceMappingURL=queue.client.d.ts.map

package/lib/aws/sqs/queue.client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"queue.client.d.ts","sourceRoot":"","sources":["../../../src/aws/sqs/queue.client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,EAAE,GAAG,IAAI,SAAS,EAAE,MAAM,cAAc,CAAC;AAEhD,OAAO,KAAK,WAAW,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,MAAM,MAAM,cAAc,CAAC;;AAEvC,qBAAa,WAAY,SAAQ,gBAG9B;CAAG;AAEN,eAAO,MAAM,MAAM,gFAGM,CAAC;AAE1B,eAAO,MAAM,aAAa,yEACqD,CAAC"}