effect-cf 0.25.3 → 0.27.0

package/dist/Artifacts-DcoXcRP5.d.mts

@@ -0,0 +1,231 @@
+import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-COCtoJXa.mjs";
+import { Context, Effect, Layer } from "effect";
+declare namespace Artifacts_d_exports {
+  export { ArtifactsBinding, ArtifactsClient, ArtifactsCommit, ArtifactsCreateOptions, ArtifactsCreateRepoResult, ArtifactsCreateTokenResult, ArtifactsDefinition, ArtifactsErrorCode, ArtifactsForkOptions, ArtifactsImportParams, ArtifactsImportSource, ArtifactsImportTarget, ArtifactsImportTargetOptions, ArtifactsListOptions, ArtifactsLogOptions, ArtifactsLogResult, ArtifactsOperation, ArtifactsOperationError, ArtifactsRepoBinding, ArtifactsRepoClient, ArtifactsRepoInfo, ArtifactsRepoListEntry, ArtifactsRepoListResult, ArtifactsRepoStatus, ArtifactsService, ArtifactsTokenInfo, ArtifactsTokenListResult, ArtifactsTokenScope, ArtifactsTokenState, ArtifactsTree, Cursor, LayerOptions, RepoName, Tag, TagClass, artifactsErrorCodes, artifactsErrorNumericCodes, isArtifactsBinding, isArtifactsRepoBinding, layer, make, makeClient };
+}
+/** Artifacts operation represented by {@link ArtifactsOperationError}. */
+type ArtifactsOperation = "createClient" | "create" | "get" | "import" | "list" | "delete" | "createToken" | "listTokens" | "getToken" | "revokeToken" | "fork" | "log" | "readCommit" | "readTree" | "cli";
+/** Documented string error codes returned by Cloudflare Artifacts. */
+declare const artifactsErrorCodes: readonly ["ALREADY_EXISTS", "NOT_FOUND", "IMPORT_IN_PROGRESS", "FORK_IN_PROGRESS", "INVALID_INPUT", "INVALID_REPO_NAME", "INVALID_TTL", "INVALID_URL", "REMOTE_AUTH_REQUIRED", "UPSTREAM_UNAVAILABLE", "MEMORY_LIMIT", "INTERNAL_ERROR"];
+/** Documented numeric error codes returned by Cloudflare Artifacts. */
+declare const artifactsErrorNumericCodes: {
+  readonly ALREADY_EXISTS: 10201;
+  readonly NOT_FOUND: 10200;
+  readonly IMPORT_IN_PROGRESS: 10302;
+  readonly FORK_IN_PROGRESS: 10303;
+  readonly INVALID_INPUT: 10100;
+  readonly INVALID_REPO_NAME: 10101;
+  readonly INVALID_TTL: 10103;
+  readonly INVALID_URL: 10104;
+  readonly REMOTE_AUTH_REQUIRED: 10106;
+  readonly UPSTREAM_UNAVAILABLE: 10401;
+  readonly MEMORY_LIMIT: 10402;
+  readonly INTERNAL_ERROR: 10400;
+};
+/** A documented Cloudflare Artifacts string error code. */
+type ArtifactsErrorCode = CloudflareArtifactsErrorCode;
+declare const ArtifactsOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "ArtifactsOperationError";
+} & Readonly<A>;
+/** Error raised when a Cloudflare Artifacts operation fails. */
+declare class ArtifactsOperationError extends ArtifactsOperationError_base<{
+  readonly binding: string;
+  readonly operation: ArtifactsOperation;
+  readonly cause: unknown;
+  /** Cloudflare string error code, when retained by the runtime. */
+  readonly code?: ArtifactsErrorCode | (string & {});
+  /** Cloudflare REST-compatible numeric error code, when retained by the runtime. */
+  readonly numericCode?: number;
+}> {
+  get message(): string;
+}
+/** Typed Cloudflare Artifacts binding definition. */
+interface ArtifactsDefinition {
+  /** Binding name from an `artifacts` entry in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+/** Repository name containing alphanumeric characters, dots, hyphens, or underscores. */
+type RepoName = string;
+/** Cursor used by repository list pagination. */
+type Cursor = string;
+/** Scope granted to a repository token. */
+type ArtifactsTokenScope = "read" | "write";
+/** Lifecycle state of a repository token. */
+type ArtifactsTokenState = "active" | "expired" | "revoked";
+/** Lifecycle state included with repositories returned by `list()`. */
+type ArtifactsRepoStatus = "ready" | "importing" | "forking";
+/** Stable repository metadata returned by Cloudflare Artifacts. */
+type ArtifactsRepoInfo = CloudflareArtifactsRepoInfo;
+/** Result of creating, importing, or forking a repository. */
+type ArtifactsCreateRepoResult = Readonly<CloudflareArtifactsCreateRepoResult>;
+/** Repository metadata returned by `list()`. */
+interface ArtifactsRepoListEntry extends ArtifactsRepoInfo {
+  readonly status: ArtifactsRepoStatus;
+}
+/** Cursor-paginated repository list result. */
+interface ArtifactsRepoListResult {
+  readonly repos: ReadonlyArray<ArtifactsRepoListEntry>;
+  readonly total: number;
+  readonly cursor?: Cursor;
+}
+/** Result of creating a repository token. */
+type ArtifactsCreateTokenResult = CloudflareArtifactsCreateTokenResult;
+/** Repository token metadata, excluding its plaintext secret. */
+type ArtifactsTokenInfo = CloudflareArtifactsTokenInfo;
+/** Repository token list result. */
+type ArtifactsTokenListResult = CloudflareArtifactsTokenListResult;
+/**
+ * Commit history returned by `log()`.
+ *
+ * Cloudflare currently documents this generated type by name but does not
+ * publish its fields in the binding reference or Workers type declarations.
+ */
+interface ArtifactsLogResult {
+  readonly [field: string]: unknown;
+}
+/**
+ * Parsed Git commit returned by `readCommit()`.
+ *
+ * Cloudflare currently documents this generated type by name but does not
+ * publish its fields in the binding reference or Workers type declarations.
+ */
+interface ArtifactsCommit {
+  readonly [field: string]: unknown;
+}
+/**
+ * Parsed Git tree returned by `readTree()`.
+ *
+ * Cloudflare currently documents this generated type by name but does not
+ * publish its fields in the binding reference or Workers type declarations.
+ */
+interface ArtifactsTree {
+  readonly [field: string]: unknown;
+}
+/** Options for `Artifacts.create()`. */
+interface ArtifactsCreateOptions {
+  /** Prevent pushes to the repository. */
+  readonly readOnly?: boolean;
+  readonly description?: string;
+  /** Initial default branch name. */
+  readonly setDefaultBranch?: string;
+}
+/** Options for cursor-paginating `Artifacts.list()`. */
+interface ArtifactsListOptions {
+  /** Page size from 1 through 200. Defaults to 50. */
+  readonly limit?: number;
+  /** Cursor returned by a previous list result. */
+  readonly cursor?: Cursor;
+}
+/** External Git source used by `Artifacts.import()`. */
+interface ArtifactsImportSource {
+  /** Full HTTPS URL of the Git repository. */
+  readonly url: string;
+  /** Source branch. Defaults to the remote's default branch. */
+  readonly branch?: string;
+  /** Shallow clone depth. */
+  readonly depth?: number;
+}
+/** Options for the target of `Artifacts.import()`. */
+interface ArtifactsImportTargetOptions {
+  readonly description?: string;
+  readonly readOnly?: boolean;
+}
+/** Target repository used by `Artifacts.import()`. */
+interface ArtifactsImportTarget {
+  readonly name: RepoName;
+  readonly opts?: ArtifactsImportTargetOptions;
+}
+/** Parameters for `Artifacts.import()`. */
+interface ArtifactsImportParams {
+  readonly source: ArtifactsImportSource;
+  readonly target: ArtifactsImportTarget;
+}
+/** Options for `ArtifactsRepoClient.fork()`. */
+interface ArtifactsForkOptions {
+  readonly description?: string;
+  readonly readOnly?: boolean;
+  /** Only copy the default branch. Defaults to `true`. */
+  readonly defaultBranchOnly?: boolean;
+}
+/** Options for `ArtifactsRepoClient.log()`. */
+interface ArtifactsLogOptions {
+  /** Branch, tag, or commit hash. */
+  readonly ref?: string;
+  readonly limit?: number;
+  readonly offset?: number;
+}
+/** Runtime repository handle, including methods absent from current shipped Workers types. */
+interface ArtifactsRepoBinding extends ArtifactsRepoInfo {
+  /**
+   * Create a Git token for the repository.
+   *
+   * Scope defaults to `"write"`. TTL is measured in seconds, defaults to
+   * 86,400, and must be between 60 and 31,536,000.
+   */
+  readonly createToken: (scope?: ArtifactsTokenScope, ttl?: number) => Promise<ArtifactsCreateTokenResult>;
+  readonly listTokens: () => Promise<ArtifactsTokenListResult>;
+  readonly revokeToken: (tokenOrId: string) => Promise<boolean>;
+  readonly fork: (name: RepoName, options?: ArtifactsForkOptions) => Promise<ArtifactsCreateRepoResult>;
+  readonly log: (options?: ArtifactsLogOptions) => Promise<ArtifactsLogResult>;
+  readonly readCommit: (hash: string) => Promise<ArtifactsCommit>;
+  readonly readTree: (hash: string) => Promise<ArtifactsTree>;
+}
+/** Cloudflare Artifacts namespace binding. */
+interface ArtifactsBinding {
+  readonly create: (name: RepoName, options?: ArtifactsCreateOptions) => Promise<ArtifactsCreateRepoResult>;
+  readonly get: (name: RepoName) => Promise<ArtifactsRepoBinding>;
+  readonly import: (params: ArtifactsImportParams) => Promise<ArtifactsCreateRepoResult>;
+  readonly list: (options?: ArtifactsListOptions) => Promise<ArtifactsRepoListResult>;
+  readonly delete: (name: RepoName) => Promise<boolean>;
+}
+/** Effect wrapper around a repository handle returned by `Artifacts.get()`. */
+interface ArtifactsRepoClient extends ArtifactsRepoInfo {
+  /**
+   * Create a Git token for the repository.
+   *
+   * Scope defaults to `"write"`. TTL is measured in seconds, defaults to
+   * 86,400, and must be between 60 and 31,536,000.
+   */
+  readonly createToken: (scope?: ArtifactsTokenScope, ttl?: number) => Effect.Effect<ArtifactsCreateTokenResult, ArtifactsOperationError>;
+  readonly listTokens: Effect.Effect<ArtifactsTokenListResult, ArtifactsOperationError>;
+  readonly revokeToken: (tokenOrId: string) => Effect.Effect<boolean, ArtifactsOperationError>;
+  readonly fork: (name: RepoName, options?: ArtifactsForkOptions) => Effect.Effect<ArtifactsCreateRepoResult, ArtifactsOperationError>;
+  readonly log: (options?: ArtifactsLogOptions) => Effect.Effect<ArtifactsLogResult, ArtifactsOperationError>;
+  readonly readCommit: (hash: string) => Effect.Effect<ArtifactsCommit, ArtifactsOperationError>;
+  readonly readTree: (hash: string) => Effect.Effect<ArtifactsTree, ArtifactsOperationError>;
+  readonly raw: ArtifactsRepoBinding;
+}
+/** Effect wrapper around a Cloudflare Artifacts namespace binding. */
+interface ArtifactsClient {
+  readonly create: (name: RepoName, options?: ArtifactsCreateOptions) => Effect.Effect<ArtifactsCreateRepoResult, ArtifactsOperationError>;
+  readonly get: (name: RepoName) => Effect.Effect<ArtifactsRepoClient, ArtifactsOperationError>;
+  readonly import: (params: ArtifactsImportParams) => Effect.Effect<ArtifactsCreateRepoResult, ArtifactsOperationError>;
+  readonly list: (options?: ArtifactsListOptions) => Effect.Effect<ArtifactsRepoListResult, ArtifactsOperationError>;
+  readonly delete: (name: RepoName) => Effect.Effect<boolean, ArtifactsOperationError>;
+  readonly rawUnsafe: Effect.Effect<ArtifactsBinding>;
+  readonly definition: ArtifactsDefinition;
+}
+declare const ArtifactsServiceTypeId: unique symbol;
+/** Nominal service marker for Artifacts services created with {@link make}. */
+interface ArtifactsService<Id extends string> {
+  readonly [ArtifactsServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions = {
+  readonly binding: string;
+};
+interface TagClass<Self, Id extends string> extends Context.ServiceClass<Self, Id, ArtifactsClient> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+/** Tests whether a value exposes the complete documented Artifacts repo handle API. */
+declare const isArtifactsRepoBinding: (value: unknown) => value is ArtifactsRepoBinding;
+/** Tests whether a value exposes the complete documented Artifacts namespace API. */
+declare const isArtifactsBinding: (value: unknown) => value is ArtifactsBinding;
+declare const makeClient: (definition: ArtifactsDefinition) => (artifacts: ArtifactsBinding) => ArtifactsClient;
+declare const layer: <Self>(tag: Context.Service<Self, ArtifactsClient>, definition: ArtifactsDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make: <Id extends string>(id: Id) => TagClass<ArtifactsService<Id>, Id>;
+declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
+//#endregion
+export { ArtifactsOperationError as a, ArtifactsTokenListResult as c, ArtifactsCreateTokenResult as i, Artifacts_d_exports as l, ArtifactsCreateOptions as n, ArtifactsRepoInfo as o, ArtifactsCreateRepoResult as r, ArtifactsTokenInfo as s, ArtifactsBinding as t, RepoName as u };

package/dist/ComputerArtifacts.d.mts

@@ -0,0 +1,55 @@
+import { a as ArtifactsOperationError, c as ArtifactsTokenListResult, i as ArtifactsCreateTokenResult, n as ArtifactsCreateOptions, o as ArtifactsRepoInfo, r as ArtifactsCreateRepoResult, s as ArtifactsTokenInfo, t as ArtifactsBinding, u as RepoName } from "./Artifacts-DcoXcRP5.mjs";
+import { Effect } from "effect";
+import { ArtifactClient, ArtifactImportOptions, ArtifactImportSource, ArtifactRepoSummary, ArtifactScope, ArtifactsCLIInput, ArtifactsCLIResult, RemoteAddFn } from "@cloudflare/computer/artifacts";
+//#region src/ComputerArtifacts.d.ts
+/** External Git source accepted by a session-scoped repository import. */
+type ComputerArtifactImportSource = Readonly<ArtifactImportSource>;
+/** Target options accepted by a session-scoped repository import. */
+type ComputerArtifactImportOptions = Readonly<ArtifactImportOptions>;
+/** Repository metadata returned by a session-scoped list operation. */
+type ComputerArtifactRepoSummary = Readonly<ArtifactRepoSummary>;
+/** Token scope accepted by the upstream session facade. */
+type ComputerArtifactScope = ArtifactScope;
+/** Optional Git remote-registration seam accepted by the argv API. */
+type ComputerArtifactsRemoteAdd = RemoteAddFn;
+/** Input to the session-scoped `artifacts` argv API. */
+type ComputerArtifactsCliInput = ArtifactsCLIInput;
+/** Result from the session-scoped `artifacts` argv API. */
+type ComputerArtifactsCliResult = Readonly<ArtifactsCLIResult>;
+/** Options used when wrapping a session-scoped Artifacts client. */
+interface ComputerArtifactsClientOptions {
+  /** Binding name attached to errors and tracing spans. Defaults to `ARTIFACTS`. */
+  readonly binding?: string;
+}
+/**
+ * Effect-native facade over `@cloudflare/computer/artifacts`.
+ *
+ * Repository names are local to {@link sessionId}. Prefixing and filtering are
+ * intentionally delegated to the upstream `createArtifact` implementation so
+ * this client and the worker-shell `artifacts` command always use the same
+ * namespace convention.
+ */
+interface ComputerArtifactsClient {
+  readonly sessionId: string;
+  readonly create: (name: RepoName, options?: ArtifactsCreateOptions) => Effect.Effect<ArtifactsCreateRepoResult, ArtifactsOperationError>;
+  readonly get: (name: RepoName) => Effect.Effect<ArtifactsRepoInfo, ArtifactsOperationError>;
+  readonly list: Effect.Effect<ReadonlyArray<ComputerArtifactRepoSummary>, ArtifactsOperationError>;
+  readonly import: (name: RepoName, source: ComputerArtifactImportSource, options?: ComputerArtifactImportOptions) => Effect.Effect<ArtifactsCreateRepoResult, ArtifactsOperationError>;
+  readonly delete: (name: RepoName) => Effect.Effect<boolean, ArtifactsOperationError>;
+  readonly createToken: (name: RepoName, scope?: ComputerArtifactScope, ttl?: number) => Effect.Effect<ArtifactsCreateTokenResult, ArtifactsOperationError>;
+  readonly listTokens: (name: RepoName) => Effect.Effect<ArtifactsTokenListResult, ArtifactsOperationError>;
+  readonly getToken: (name: RepoName, id: string) => Effect.Effect<ArtifactsTokenInfo, ArtifactsOperationError>;
+  readonly revokeToken: (name: RepoName, tokenOrId: string) => Effect.Effect<boolean, ArtifactsOperationError>;
+  readonly cli: (input: ComputerArtifactsCliInput) => Effect.Effect<ComputerArtifactsCliResult, ArtifactsOperationError>;
+  readonly rawUnsafe: Effect.Effect<ArtifactClient>;
+}
+/** Wraps an already-created upstream session client. */
+declare const fromClient: (client: ArtifactClient, options?: ComputerArtifactsClientOptions) => ComputerArtifactsClient;
+/**
+ * Creates an Effect-native session client directly from a Worker Artifacts
+ * binding. `@cloudflare/computer` is loaded only when this Effect runs, keeping
+ * the optional peer out of applications that do not use this integration.
+ */
+declare const makeClient: (bindingValue: ArtifactsBinding, sessionId: string, options?: ComputerArtifactsClientOptions | undefined) => Effect.Effect<ComputerArtifactsClient, ArtifactsOperationError, never>;
+//#endregion
+export { ComputerArtifactImportOptions, ComputerArtifactImportSource, ComputerArtifactRepoSummary, ComputerArtifactScope, ComputerArtifactsCliInput, ComputerArtifactsCliResult, ComputerArtifactsClient, ComputerArtifactsClientOptions, ComputerArtifactsRemoteAdd, fromClient, makeClient };

package/dist/ComputerArtifacts.mjs

@@ -0,0 +1,95 @@
+import { t as ArtifactsOperationError } from "./Artifacts-BhWrdyqX.mjs";
+import { Effect } from "effect";
+//#region src/ComputerArtifacts.ts
+const artifactsErrorDetails = (cause) => {
+	if (typeof cause !== "object" || cause === null) return {};
+	const code = Reflect.get(cause, "code");
+	const numericCode = Reflect.get(cause, "numericCode");
+	return {
+		...typeof code === "string" ? { code } : {},
+		...typeof numericCode === "number" ? { numericCode } : {}
+	};
+};
+const operationError = (binding, operation, cause) => new ArtifactsOperationError({
+	binding,
+	operation,
+	cause,
+	...artifactsErrorDetails(cause)
+});
+const tryOperation = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => operationError(binding, operation, cause)
+});
+const spanOptions = (binding, sessionId, operation) => ({ attributes: {
+	binding,
+	sessionId,
+	operation
+} });
+/** Wraps an already-created upstream session client. */
+const fromClient = (client, options = {}) => {
+	const binding = options.binding ?? "ARTIFACTS";
+	const { sessionId } = client;
+	return {
+		sessionId,
+		create: Effect.fn("ComputerArtifacts.create", spanOptions(binding, sessionId, "create"))(function* (name, createOptions) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "create", () => client.create(name, createOptions));
+		}),
+		get: Effect.fn("ComputerArtifacts.get", spanOptions(binding, sessionId, "get"))(function* (name) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "get", () => client.get(name));
+		}),
+		list: tryOperation(binding, "list", () => client.list()).pipe(Effect.withSpan("ComputerArtifacts.list", spanOptions(binding, sessionId, "list"))),
+		import: Effect.fn("ComputerArtifacts.import", spanOptions(binding, sessionId, "import"))(function* (name, source, importOptions) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "import", () => client.import(name, source, importOptions));
+		}),
+		delete: Effect.fn("ComputerArtifacts.delete", spanOptions(binding, sessionId, "delete"))(function* (name) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "delete", () => client.delete(name));
+		}),
+		createToken: Effect.fn("ComputerArtifacts.createToken", spanOptions(binding, sessionId, "createToken"))(function* (name, scope, ttl) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "createToken", () => client.createToken(name, scope, ttl));
+		}),
+		listTokens: Effect.fn("ComputerArtifacts.listTokens", spanOptions(binding, sessionId, "listTokens"))(function* (name) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "listTokens", () => client.listTokens(name));
+		}),
+		getToken: Effect.fn("ComputerArtifacts.getToken", spanOptions(binding, sessionId, "getToken"))(function* (name, id) {
+			yield* Effect.annotateCurrentSpan({
+				repo: name,
+				tokenId: id
+			});
+			return yield* tryOperation(binding, "getToken", () => client.getToken(name, id));
+		}),
+		revokeToken: Effect.fn("ComputerArtifacts.revokeToken", spanOptions(binding, sessionId, "revokeToken"))(function* (name, tokenOrId) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "revokeToken", () => client.revokeToken(name, tokenOrId));
+		}),
+		cli: Effect.fn("ComputerArtifacts.cli", spanOptions(binding, sessionId, "cli"))(function* (input) {
+			yield* Effect.annotateCurrentSpan("argv", input.argv.join(" "));
+			return yield* tryOperation(binding, "cli", () => client.cli(input));
+		}),
+		rawUnsafe: Effect.succeed(client)
+	};
+};
+/**
+* Creates an Effect-native session client directly from a Worker Artifacts
+* binding. `@cloudflare/computer` is loaded only when this Effect runs, keeping
+* the optional peer out of applications that do not use this integration.
+*/
+const makeClient = Effect.fn("ComputerArtifacts.makeClient")(function* (bindingValue, sessionId, options = {}) {
+	const binding = options.binding ?? "ARTIFACTS";
+	const computerArtifacts = yield* Effect.tryPromise({
+		try: () => import("@cloudflare/computer/artifacts"),
+		catch: (cause) => operationError(binding, "createClient", cause)
+	});
+	const client = yield* Effect.try({
+		try: () => computerArtifacts.createArtifact(bindingValue, sessionId),
+		catch: (cause) => operationError(binding, "createClient", cause)
+	});
+	return fromClient(client, { binding });
+});
+//#endregion
+export { fromClient, makeClient };