alchemy-effect 0.2.0 → 0.4.0

package/src/event.ts

@@ -1,11 +1,17 @@
 export type ApplyStatus =
+  | "attaching"
+  | "post-attach"
   | "pending"
+  | "pre-creating"
   | "creating"
+  | "creating replacement"
   | "created"
   | "updating"
   | "updated"
   | "deleting"
   | "deleted"
+  | "replacing"
+  | "replaced"
   | "success"
   | "fail";
 

package/src/exports.ts

@@ -0,0 +1,21 @@
+/*
+This file is used to provide a minimal set of exported types required to solve portability
+issues in sub-modules (e.g. cloudflare/worker).
+
+Sub-modules are expected to `export type * from "../../exports.ts";` to ensure that the minimal set of types are exported.
+
+This is instead of:
+1. `export type * from "../../index.ts";` which would export too many types
+2. `export type * as Alchemy from "../../index.ts";` which creates very long, confusing types.
+
+TODO(sam): figure out a way to avoid this entirely
+*/
+
+export type * from "./$.ts";
+export type * from "./binding.ts";
+export type * from "./capability.ts";
+export type * from "./policy.ts";
+export type * from "./provider.ts";
+export type * from "./resource.ts";
+export type * from "./runtime.ts";
+export type * from "./service.ts";

package/src/index.ts

@@ -1,22 +1,27 @@
+export * from "./$.ts";
 export * from "./app.ts";
 export * from "./apply.ts";
-export * from "./approve.ts";
 export * from "./binding.ts";
 export * from "./capability.ts";
 export * from "./destroy.ts";
 export * from "./dot-alchemy.ts";
-export * from "./env.ts";
+export { env, toEnvKey, type Env } from "./env.ts";
 export * from "./event.ts";
+export * from "./input.ts";
+export * as Output from "./output.ts";
 export * from "./phase.ts";
 export * from "./plan.ts";
 export * from "./policy.ts";
 export * from "./provider.ts";
 export * from "./resource.ts";
 export * from "./runtime.ts";
+export * from "./ref.ts";
 export * from "./service.ts";
+export * from "./stack.ts";
 export * from "./type.ts";
+export * from "./unknown.ts";
+export * from "./stage.ts";
+export * from "./user.ts";
+export { assertDefined } from "./util.ts";
 
-// export * as AWS from "./aws/index.ts";
-// export * as CLI from "./cli/index.ts";
-// export * as Cloudflare from "./cloudflare/index.ts";
 export * as State from "./state.ts";

package/src/input.ts

@@ -0,0 +1,81 @@
+import type * as S from "effect/Schema";
+import type { Primitive } from "./data.ts";
+import type { Output } from "./output.ts";
+
+export type Function = (...args: any[]) => any;
+export type Constructor = new (...args: any[]) => any;
+export type PolicyLike = { kind: "alchemy/Policy" };
+
+export type Input<T> =
+  | T
+  | (T extends S.Schema<any>
+      ? never
+      :
+          | Output<T, any, any>
+          | (T extends Primitive
+              ? never
+              : T extends any[]
+                ? number extends T["length"]
+                  ? Input<T[number]>[]
+                  : Inputs<T>
+                : T extends object
+                  ? { [K in keyof T]: Input<T[K]> }
+                  : never));
+
+export type InputProps<
+  T extends Record<string, any>,
+  Static extends keyof T = never,
+> = {
+  [K in keyof T]: K extends Static ? T[K] : Input<T[K]>;
+};
+
+export declare namespace Input {
+  export type Resolve<T> =
+    T extends Output<infer U>
+      ? U
+      : T extends
+            | Primitive
+            | Constructor
+            | Function
+            | S.Schema<any>
+            | PolicyLike
+        ? T
+        : T extends any[]
+          ? ResolveArray<T>
+          : T extends Record<string, any>
+            ? {
+                [k in keyof T]: Input.Resolve<T[k]>;
+              }
+            : never;
+
+  export type ResolveArray<T extends any[]> = number extends T["length"]
+    ? Resolve<T[number]>[]
+    : ResolveTuple<T>;
+
+  export type ResolveTuple<
+    T extends any[],
+    // TODO(sam): I added the accumulator because it resolved infinite type instantiation
+    Accum extends any[] = [],
+  > = T extends [infer H, ...infer Tail]
+    ? ResolveTuple<Tail, [...Accum, Input.Resolve<H>]>
+    : Accum;
+
+  export type ResolveProps<Props extends Record<string, any>> = {
+    [k in keyof Props]: Input.Resolve<Props[k]>;
+  };
+
+  export type ResolveOpaque<T> =
+    // use true extends IsOut to avoid distribution in the case where we have an Out<T>
+    // because T is a clean type, e.g. Input<SubnetProps> should just be SubnetProps (don't bother resolving the recursive input type variants)
+    true extends IsOut<T> ? ResolveOut<T> : Resolve<T>;
+  export type IsOut<T> = T extends Output<infer U> ? true : never;
+
+  export type ResolveOut<T> = T extends Output<infer U> ? U : never;
+}
+
+export type Inputs<T extends any[], Out extends any[] = []> = T extends [
+  infer H,
+  ...infer T,
+]
+  ? Inputs<T, [...Out, Input<H>]>
+  : Out;

package/src/instance-id.ts

@@ -0,0 +1,16 @@
+import * as Effect from "effect/Effect";
+
+/** A 16-byte (128-bit) random hex-encoded string representing an physical instance of a logical resource */
+export type InstanceId = string;
+
+/**
+ * @returns Hex-encoded instance ID (16 random bytes)
+ */
+export const generateInstanceId = () =>
+  Effect.sync(() => {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    return Array.from(bytes)
+      .map((b) => b.toString(16).padStart(2, "0"))
+      .join("");
+  });