alchemy 0.1.16 → 0.1.18

package/src/input.ts

@@ -1,16 +1,19 @@
 import type { Output } from "./output";
+import type { Secret } from "./secret";
 
 export type Inputs<P extends any[]> = P extends [infer First, ...infer Rest]
   ? [Input<First>, ...Inputs<Rest>]
   : [];
 
-export type Input<T = any> =
-  | T
-  | Output<T>
-  | (T extends any[] ? Inputs<T> : never)
-  | (T extends string | number | boolean ? Output<T> : never)
-  | (T extends object
-      ? {
-          [k in keyof T]: Input<T[k]>;
-        }
-      : never);
+export type Input<T = any> = T extends Secret
+  ? T | Output<T>
+  :
+      | T
+      | Output<T>
+      | (T extends any[] ? Inputs<T> : never)
+      | (T extends string | number | boolean ? Output<T> : never)
+      | (T extends object
+          ? {
+              [k in keyof T]: Input<T[k]>;
+            }
+          : never);

package/src/output.ts

@@ -1,3 +1,5 @@
+import type { Secret } from "./secret";
+
 export function isOutput<T>(value: any): value is Output<T> {
   return (
     value && typeof value === "object" && typeof value.apply === "function"
@@ -45,15 +47,17 @@ export class OutputChain<T, U> {
 
 export type Resolved<O> = O extends Output<infer U>
   ? U
-  : O extends null
-    ? O
-    : O extends any[]
-      ? ResolveN<O>
-      : O extends object
-        ? {
-            [k in keyof O]: Resolved<O[k]>;
-          }
-        : O;
+  : O extends Secret
+    ? Secret
+    : O extends null
+      ? O
+      : O extends any[]
+        ? ResolveN<O>
+        : O extends object
+          ? {
+              [k in keyof O]: Resolved<O[k]>;
+            }
+          : O;
 
 type ResolveN<O extends any[]> = O extends [infer First, ...infer Rest]
   ? [Resolved<First>, ...ResolveN<Rest>]

package/src/secret.ts

@@ -0,0 +1,41 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import type { Input } from "./input";
+import { type Output, isOutput } from "./output";
+
+const passphraseContext = new AsyncLocalStorage<string>();
+
+export function secret<S extends Input<string> | undefined>(
+  unencrypted: S,
+): S extends undefined
+  ? never
+  : S extends Output<string>
+    ? Output<Secret>
+    : Secret {
+  if (unencrypted === undefined) {
+    throw new Error("Secret cannot be undefined");
+  }
+  return (
+    isOutput(unencrypted) ? unencrypted.apply(secret) : new Secret(unencrypted)
+  ) as any;
+}
+
+export class Secret {
+  public readonly type = "secret";
+  constructor(readonly unencrypted: string) {}
+}
+
+export function setSecretPassphrase(passphrase: string) {
+  passphraseContext.enterWith(passphrase);
+}
+
+export function getSecretPassphrase(): string {
+  const passphrase = passphraseContext.getStore();
+  if (!passphrase) {
+    throw new Error("No passphrase set");
+  }
+  return passphrase;
+}
+
+export function tryGetSecretPassphrase(): string | undefined {
+  return passphraseContext.getStore();
+}

package/src/serde.ts

@@ -0,0 +1,46 @@
+import { decryptWithKey, encryptWithKey } from "./encrypt";
+import { Secret, getSecretPassphrase } from "./secret";
+
+export async function serialize(value: any): Promise<any> {
+  if (Array.isArray(value)) {
+    return Promise.all(value.map(serialize));
+  } else if (value instanceof Secret) {
+    return {
+      "@secret": await encryptWithKey(value.unencrypted, getSecretPassphrase()),
+    };
+  } else if (value && typeof value === "object") {
+    return Object.fromEntries(
+      await Promise.all(
+        Object.entries(value).map(async ([key, value]) => [
+          key,
+          await serialize(value),
+        ]),
+      ),
+    );
+  }
+  return value;
+}
+
+export async function deserialize(value: any): Promise<any> {
+  if (Array.isArray(value)) {
+    return await Promise.all(
+      value.map(async (item) => await deserialize(item)),
+    );
+  } else if (value && typeof value === "object") {
+    if (typeof value["@secret"] === "string") {
+      return new Secret(
+        await decryptWithKey(value["@secret"], getSecretPassphrase()),
+      );
+    } else {
+      return Object.fromEntries(
+        await Promise.all(
+          Object.entries(value).map(async ([key, value]) => [
+            key,
+            await deserialize(value),
+          ]),
+        ),
+      );
+    }
+  }
+  return value;
+}

package/src/state.ts

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { ignore } from "./error";
+import { deserialize, serialize } from "./serde";
 
 export interface State {
   status:
@@ -79,7 +80,7 @@ export class FileSystemStateStore implements StateStore {
         await this.getPath(key),
         "utf8",
       );
-      return JSON.parse(content) as State;
+      return (await deserialize(JSON.parse(content))) as State;
     } catch (error: any) {
       if (error.code === "ENOENT") {
         return undefined;
@@ -91,7 +92,7 @@ export class FileSystemStateStore implements StateStore {
   async set(key: string, value: State): Promise<void> {
     return fs.promises.writeFile(
       await this.getPath(key),
-      JSON.stringify(value, null, 2),
+      JSON.stringify(await serialize(value), null, 2),
     );
   }