alchemy 2.0.0-beta.44 → 2.0.0-beta.45

package/src/Util/instance.ts

@@ -1,9 +0,0 @@
-export type Instance<T> = T extends new (_: never) => infer I
-  ? I
-  : T extends { id: string }
-    ? string extends T["id"]
-      ? T
-      : T extends new (...args: any) => infer I
-        ? I
-        : never
-    : never;

package/src/Util/pointer.ts

@@ -1,5 +0,0 @@
-export type Pointer<T> = T | (() => T);
-
-export declare namespace Pointer {
-  export type Resolve<R> = R extends () => infer T ? T : R;
-}

package/src/Util/schema-to-type.ts

@@ -1,456 +0,0 @@
-/**
- * Converts an Effect Schema to TypeScript type definitions.
- *
- * This module recursively discovers all named types (like S.Class with identifiers)
- * and generates interface definitions for each.
- *
- * @module
- */
-
-import * as Predicate from "effect/Predicate";
-import type * as Schema from "effect/Schema";
-import * as AST from "effect/SchemaAST";
-
-/**
- * The result of generating TypeScript type definitions.
- */
-export interface TypeDefinitionResult {
-  /**
-   * The type expressions for each input schema.
-   * Each expression is either an identifier (for named types) or an inline type.
-   */
-  readonly exprs: string[];
-
-  /**
-   * All type definitions as a single string.
-   * Contains all recursively discovered named types, separated by newlines.
-   * Types are deduplicated - if multiple schemas reference the same type,
-   * it will only appear once.
-   */
-  readonly types: string;
-}
-
-/**
- * Generates TypeScript type definitions from one or more schemas.
- *
- * All schemas share a single type environment, so types referenced by
- * multiple schemas are only generated once (deduplication).
- */
-export const schemaToType = <Schemas extends Schema.Schema<any>[]>(
-  ...schemas: Schemas
-): TypeDefinitionResult => {
-  const typesMap: Record<string, string> = {};
-  const processing = new Set<string>();
-
-  const exprs = schemas.map((schema) =>
-    go(schema.ast, { types: typesMap, processing }, "handle-identifier"),
-  );
-
-  const types = Object.values(typesMap).join("\n\n");
-
-  return {
-    exprs,
-    types,
-  };
-};
-
-interface GoOptions {
-  readonly types: Record<string, string>;
-  readonly processing: Set<string>;
-}
-
-/**
- * Converts an AST node to a TypeScript type reference or inline type.
- * Returns the identifier/type expression and collects named types.
- */
-export const fromAST = (
-  ast: AST.AST,
-  options?: { types?: string[] },
-): string => {
-  const typesMap: Record<string, string> = {};
-  const processing = new Set<string>();
-  const result = go(ast, { types: typesMap, processing }, "handle-identifier");
-
-  if (options?.types) {
-    for (const def of Object.values(typesMap)) {
-      options.types.push(def);
-    }
-  }
-
-  return result;
-};
-
-function getDescription(ast: AST.AST): string | undefined {
-  const desc = AST.resolveDescription(ast);
-  if (desc === undefined) return undefined;
-
-  if (AST.isString(ast) && desc === "a string") return undefined;
-  if (AST.isNumber(ast) && desc === "a number") return undefined;
-  if (AST.isBoolean(ast) && desc === "a boolean") return undefined;
-  if (AST.isBigInt(ast) && desc === "a bigint") return undefined;
-  if (AST.isSymbol(ast) && desc === "a symbol") return undefined;
-  if (
-    AST.isObjectKeyword(ast) &&
-    desc === "an object in the TypeScript meaning, i.e. the `object` type"
-  )
-    return undefined;
-
-  return desc;
-}
-
-/**
- * Gets the identifier for a named type.
- *
- * Returns an identifier for:
- * - S.Class types (Declarations with typeParameters and encoding)
- * - Any schema with an explicit identifier annotation
- * - Suspended types with identifiers
- *
- * Does NOT return identifier for simple transformations like NumberFromString.
- */
-function getIdentifier(ast: AST.AST): string | undefined {
-  if (AST.isDeclaration(ast)) {
-    return AST.resolveIdentifier(ast);
-  }
-
-  if (AST.isSuspend(ast)) {
-    const id = AST.resolveIdentifier(ast);
-    if (id !== undefined) return id;
-    const resolved = ast.thunk();
-    return getIdentifier(resolved);
-  }
-
-  // For schemas with encoding chains (transforms like NumberFromString),
-  // don't treat as named types - just use the decoded type
-  if (ast.encoding) {
-    return undefined;
-  }
-
-  return AST.resolveIdentifier(ast);
-}
-
-function formatComment(
-  description: string | undefined,
-  indent: string,
-): string {
-  if (!description) return "";
-  const lines = description.split("\n");
-  if (lines.length === 1) {
-    return `${indent}/** ${description} */\n`;
-  }
-  return `${indent}/**\n${lines.map((line) => `${indent} * ${line}`).join("\n")}\n${indent} */\n`;
-}
-
-function escapePropertyName(name: PropertyKey): string {
-  if (typeof name === "symbol") {
-    return `[${String(name)}]`;
-  }
-  const str = String(name);
-  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(str)) {
-    return str;
-  }
-  return JSON.stringify(str);
-}
-
-/**
- * Gets the type body for a named type (S.Class, etc).
- * Navigates through Declarations to find the actual structure.
- */
-function getTypeBody(ast: AST.AST, options: GoOptions): string {
-  if (AST.isSuspend(ast)) {
-    return getTypeBody(ast.thunk(), options);
-  }
-
-  if (AST.isDeclaration(ast)) {
-    if (ast.typeParameters.length > 0) {
-      return go(ast.typeParameters[0], options, "ignore-identifier");
-    }
-    return "unknown";
-  }
-
-  return go(ast, options, "ignore-identifier");
-}
-
-function go(
-  ast: AST.AST,
-  options: GoOptions,
-  identifierHandling: "handle-identifier" | "ignore-identifier",
-): string {
-  // Handle identifier references first
-  if (identifierHandling === "handle-identifier") {
-    const id = getIdentifier(ast);
-    if (id !== undefined) {
-      if (options.processing.has(id)) {
-        return id;
-      }
-
-      if (!(id in options.types)) {
-        options.processing.add(id);
-
-        const typeBody = getTypeBody(ast, options);
-
-        if (typeBody.startsWith("{")) {
-          options.types[id] = `interface ${id} ${typeBody}`;
-        } else {
-          options.types[id] = `type ${id} = ${typeBody};`;
-        }
-
-        options.processing.delete(id);
-      }
-      return id;
-    }
-  }
-
-  // For Declarations without identifier (or when ignoring), get the body from typeParameters
-  if (AST.isDeclaration(ast) && identifierHandling === "ignore-identifier") {
-    if (ast.typeParameters.length > 0) {
-      return go(ast.typeParameters[0], options, identifierHandling);
-    }
-    return "unknown";
-  }
-
-  // Handle encoding chains (transformations): use the decoded type
-  if (ast.encoding) {
-    return go(AST.toType(ast), options, identifierHandling);
-  }
-
-  switch (ast._tag) {
-    case "Declaration": {
-      if (ast.typeParameters.length > 0) {
-        const id = getIdentifier(ast);
-        if (id) {
-          const params = ast.typeParameters
-            .map((p) => go(p, options, "handle-identifier"))
-            .join(", ");
-          return `${id}<${params}>`;
-        }
-      }
-      return "unknown";
-    }
-
-    case "Literal": {
-      const literal = ast.literal;
-      if (Predicate.isString(literal)) {
-        return JSON.stringify(literal);
-      }
-      if (Predicate.isNumber(literal)) {
-        return String(literal);
-      }
-      if (Predicate.isBoolean(literal)) {
-        return String(literal);
-      }
-      if (Predicate.isBigInt(literal)) {
-        return `${String(literal)}n`;
-      }
-      return "unknown";
-    }
-
-    case "Null":
-      return "null";
-
-    case "UniqueSymbol":
-      return `typeof ${String(ast.symbol)}`;
-
-    case "Undefined":
-      return "undefined";
-
-    case "Void":
-      return "void";
-
-    case "Never":
-      return "never";
-
-    case "Unknown":
-      return "unknown";
-
-    case "Any":
-      return "any";
-
-    case "String":
-      return "string";
-
-    case "Number":
-      return "number";
-
-    case "Boolean":
-      return "boolean";
-
-    case "BigInt":
-      return "bigint";
-
-    case "Symbol":
-      return "symbol";
-
-    case "ObjectKeyword":
-      return "object";
-
-    case "Enum": {
-      const values = ast.enums.map(([_, value]) =>
-        typeof value === "string" ? JSON.stringify(value) : String(value),
-      );
-      return values.join(" | ");
-    }
-
-    case "TemplateLiteral": {
-      return formatTemplateLiteral(ast, options);
-    }
-
-    case "Arrays": {
-      return formatArrays(ast, options);
-    }
-
-    case "Objects": {
-      return formatObjects(ast, options);
-    }
-
-    case "Union": {
-      const members = ast.types.map((t) => go(t, options, "handle-identifier"));
-      const unique = [...new Set(members)];
-      if (unique.length === 1) {
-        return unique[0];
-      }
-      return unique.join(" | ");
-    }
-
-    case "Suspend": {
-      const id = getIdentifier(ast);
-      if (id !== undefined) {
-        if (options.processing.has(id)) {
-          return id;
-        }
-        if (!(id in options.types)) {
-          options.processing.add(id);
-          const typeBody = getTypeBody(ast, options);
-          if (typeBody.startsWith("{")) {
-            options.types[id] = `interface ${id} ${typeBody}`;
-          } else {
-            options.types[id] = `type ${id} = ${typeBody};`;
-          }
-          options.processing.delete(id);
-        }
-        return id;
-      }
-      const resolved = ast.thunk();
-      return go(resolved, options, identifierHandling);
-    }
-  }
-}
-
-function formatTemplateLiteral(
-  ast: AST.TemplateLiteral,
-  options: GoOptions,
-): string {
-  let result = "`";
-  for (const part of ast.parts) {
-    if (AST.isLiteral(part) && typeof part.literal === "string") {
-      result += part.literal;
-    } else {
-      const spanType = formatTemplateLiteralSpan(part, options);
-      result += "${" + spanType + "}";
-    }
-  }
-  result += "`";
-  return result;
-}
-
-function formatTemplateLiteralSpan(type: AST.AST, options: GoOptions): string {
-  switch (type._tag) {
-    case "String":
-      return "string";
-    case "Number":
-      return "number";
-    case "Literal":
-      return typeof type.literal === "string"
-        ? JSON.stringify(type.literal)
-        : String(type.literal);
-    case "TemplateLiteral":
-      return formatTemplateLiteral(type, options);
-    case "Union":
-      return type.types
-        .map((t) => formatTemplateLiteralSpan(t, options))
-        .join(" | ");
-    default:
-      return go(type, options, "handle-identifier");
-  }
-}
-
-function formatArrays(ast: AST.Arrays, options: GoOptions): string {
-  const elements: string[] = [];
-
-  for (const element of ast.elements) {
-    const isOpt = AST.isOptional(element);
-    let typeStr: string;
-    if (isOpt && AST.isUnion(element)) {
-      const nonUndefined = element.types.filter((t) => !AST.isUndefined(t));
-      if (nonUndefined.length === 1) {
-        typeStr = go(nonUndefined[0], options, "handle-identifier");
-      } else if (nonUndefined.length > 1) {
-        typeStr = nonUndefined
-          .map((t) => go(t, options, "handle-identifier"))
-          .join(" | ");
-      } else {
-        typeStr = go(element, options, "handle-identifier");
-      }
-    } else {
-      typeStr = go(element, options, "handle-identifier");
-    }
-    const description = getDescription(element);
-    const comment = description ? `/* ${description} */ ` : "";
-    if (isOpt) {
-      elements.push(`${comment}${typeStr}?`);
-    } else {
-      elements.push(`${comment}${typeStr}`);
-    }
-  }
-
-  if (ast.rest.length > 0) {
-    const restType = go(ast.rest[0], options, "handle-identifier");
-    if (ast.elements.length === 0 && ast.rest.length === 1) {
-      if (!ast.isMutable) {
-        return `readonly ${restType}[]`;
-      }
-      return `${restType}[]`;
-    }
-    elements.push(`...${restType}[]`);
-  }
-
-  const prefix = !ast.isMutable ? "readonly " : "";
-  return `${prefix}[${elements.join(", ")}]`;
-}
-
-function formatObjects(ast: AST.Objects, options: GoOptions): string {
-  if (ast.propertySignatures.length === 0 && ast.indexSignatures.length === 0) {
-    return "{}";
-  }
-
-  const lines: string[] = [];
-
-  for (const ps of ast.propertySignatures) {
-    if (typeof ps.name !== "string" && typeof ps.name !== "number") {
-      continue;
-    }
-
-    const propName = escapePropertyName(ps.name);
-    const typeStr = go(ps.type, options, "handle-identifier");
-    const description = getDescription(ps.type);
-    const comment = formatComment(description, "  ");
-    const isMutable = ps.type.context?.isMutable ?? false;
-    const readonly = isMutable ? "" : "readonly ";
-    const optional = AST.isOptional(ps.type) ? "?" : "";
-
-    lines.push(`${comment}  ${readonly}${propName}${optional}: ${typeStr};`);
-  }
-
-  for (const is of ast.indexSignatures) {
-    const paramType = go(is.parameter, options, "handle-identifier");
-    const valueType = go(is.type, options, "handle-identifier");
-    const readonly = "readonly ";
-    lines.push(`  ${readonly}[key: ${paramType}]: ${valueType};`);
-  }
-
-  if (lines.length === 0) {
-    return "{}";
-  }
-
-  return `{\n${lines.join("\n")}\n}`;
-}

package/src/Util/todo.ts

@@ -1,4 +0,0 @@
-import * as Effect from "effect/Effect";
-
-export const todo = (message?: string) =>
-  Effect.die(message ?? `Not implemented`);

package/src/Variable.ts

@@ -1,44 +0,0 @@
-import * as Config from "effect/Config";
-import * as Effect from "effect/Effect";
-import * as Output from "./Output.ts";
-import { toOutput } from "./Secret.ts";
-
-/**
- * The shapes a {@link variable} can be derived from.
- */
-export type VariableInput<T, R = never> =
-  | T
-  | Effect.Effect<T, any, R>
-  | Config.Config<T>;
-
-/**
- * Bind a non-secret value into the active {@link RuntimeContext} (e.g. a
- * Cloudflare Worker's `env`) under the given `name`. Counterpart to
- * {@link Secret} for plain (non-redacted) values — the resource provider
- * deploys it as `plain_text` / `json` rather than `secret_text`.
- *
- * The result is an `Output<T>` — `yield*`-ing it returns an `Accessor<T>`
- * that resolves the value at runtime.
- *
- * @example One-arg shortcut — reads `Config.string("DATABASE_URL")`
- * ```ts
- * const url = yield* Alchemy.Variable("DATABASE_URL");
- * ```
- *
- * @example From a literal
- * ```ts
- * const port = yield* Alchemy.Variable("PORT", 3000);
- * ```
- */
-export function Variable(name: string): Output.Output<string, never>;
-export function Variable<T, R = never>(
-  name: string,
-  value: VariableInput<T, R>,
-): Output.Output<T, R>;
-export function Variable<T = string, R = never>(
-  name: string,
-  value?: VariableInput<T, R>,
-): Output.Output<T, R> {
-  const source: any = value ?? Config.string(name);
-  return Output.named(toOutput<T, R>(source), name);
-}