@distilled.cloud/core 0.30.3 → 1.0.0-rc.1

package/src/schemas.ts

@@ -1,128 +0,0 @@
-/**
- * Cloud-agnostic binary HTTP body schemas.
- *
- * These schemas describe the wire-shape of raw byte bodies — request bodies
- * for `application/octet-stream` uploads (e.g. R2 PutObject, S3 PutObject,
- * GCS object insert) and response bodies for the corresponding downloads.
- * They are intentionally cloud-agnostic so every distilled SDK can share a
- * single binary-body contract.
- */
-
-import * as Schema from "effect/Schema";
-import * as Stream from "effect/Stream";
-import type * as HttpClientError from "effect/unstable/http/HttpClientError";
-
-/**
- * Schema for `Blob` request bodies (browser/web standard binary blob).
- */
-export const BlobSchema = Schema.declare(
-  (input): input is Blob =>
-    typeof Blob !== "undefined" && input instanceof Blob,
-  {
-    identifier: "Blob",
-    description: "A Blob to send as the raw HTTP request body",
-  },
-);
-
-/**
- * Schema for `Uint8Array` request bodies.
- */
-export const Uint8ArraySchema = Schema.declare(
-  (input): input is Uint8Array =>
-    typeof Uint8Array !== "undefined" && input instanceof Uint8Array,
-  {
-    identifier: "Uint8Array",
-    description: "A Uint8Array to send as the raw HTTP request body",
-  },
-);
-
-/**
- * Schema for `ArrayBuffer` request bodies.
- */
-export const ArrayBufferSchema = Schema.declare(
-  (input): input is ArrayBuffer =>
-    typeof ArrayBuffer !== "undefined" && input instanceof ArrayBuffer,
-  {
-    identifier: "ArrayBuffer",
-    description: "An ArrayBuffer to send as the raw HTTP request body",
-  },
-);
-
-/**
- * Schema for `ReadableStream<Uint8Array>` request bodies (web-platform
- * streaming API).
- */
-export const ReadableStreamSchema = Schema.declare(
-  (input): input is ReadableStream<Uint8Array> =>
-    typeof ReadableStream !== "undefined" && input instanceof ReadableStream,
-  {
-    identifier: "ReadableStream",
-    description:
-      "A ReadableStream<Uint8Array> to send as the raw HTTP request body",
-  },
-);
-
-/**
- * Schema for Effect `Stream.Stream<Uint8Array>` request bodies. Accepts any
- * Stream regardless of error/requirements channels — the runtime treats it
- * as an opaque source of bytes.
- */
-export const StreamSchema = Schema.declare(
-  (input): input is Stream.Stream<Uint8Array, unknown, unknown> =>
-    Stream.isStream(input as Stream.Stream<unknown, unknown, unknown>),
-  {
-    identifier: "Stream",
-    description:
-      "An Effect Stream.Stream<Uint8Array> to send as the raw HTTP request body",
-  },
-);
-
-/**
- * Schema for raw `application/octet-stream` request bodies (e.g. R2
- * `PutObject`, S3 `PutObject`). Inputs are intentionally wide — any
- * standard JS binary source plus Effect `Stream.Stream<Uint8Array>` is
- * accepted. The on-the-wire `Content-Type` is supplied by the caller
- * through the operation's `content-type` header field; the runtime falls
- * back to `application/octet-stream` when none is provided.
- */
-export const BinaryBodySchema = Schema.Union([
-  BlobSchema,
-  Uint8ArraySchema,
-  ArrayBufferSchema,
-  ReadableStreamSchema,
-  StreamSchema,
-  Schema.String,
-]);
-
-/**
- * TypeScript type for raw HTTP request body content. Inputs are wide;
- * outputs (downloads) are always Effect `Stream.Stream<Uint8Array>`.
- */
-export type BinaryBody =
-  | Blob
-  | Uint8Array
-  | ArrayBuffer
-  | ReadableStream<Uint8Array>
-  | Stream.Stream<Uint8Array, unknown, unknown>
-  | string;
-
-/**
- * Marker schema for raw `application/octet-stream` download responses (e.g.
- * R2 `GetObject`). The runtime never decodes through this schema — it
- * detects `responseContentType: "binary"` on the operation's HTTP trait and
- * surfaces the response body directly as an Effect
- * `Stream.Stream<Uint8Array, HttpClientError.HttpClientError>`. This schema
- * is exported solely so generated service files have something to assign
- * to the operation's output schema slot.
- */
-export const BinaryStreamResponseSchema = Schema.declare(
-  (
-    input,
-  ): input is Stream.Stream<Uint8Array, HttpClientError.HttpClientError> =>
-    Stream.isStream(input as Stream.Stream<unknown, unknown, unknown>),
-  {
-    identifier: "BinaryStreamResponse",
-    description:
-      "An Effect Stream.Stream<Uint8Array> surfacing a raw octet-stream download response",
-  },
-);

package/src/sensitive.ts

@@ -1,119 +0,0 @@
-/**
- * Sensitive data schemas for handling credentials and secrets.
- *
- * This module provides schemas that wrap sensitive data in Effect's Redacted type,
- * preventing accidental logging of secrets like passwords and tokens.
- *
- * @example
- * ```ts
- * import { SensitiveString, SensitiveOutputString } from "@distilled.cloud/core/sensitive";
- *
- * // Inputs: use Sensitive* — accepts plain string OR Redacted (convenience).
- * const CreateInput = Schema.Struct({ plain_text: SensitiveString });
- * API.create({ plain_text: "my-secret" });             // ok
- * API.create({ plain_text: Redacted.make("my-secret") }); // also ok
- *
- * // Outputs: use SensitiveOutput* — decoded type is strictly Redacted, so
- * // consumers never need to coerce.
- * const CreateOutput = Schema.Struct({ plain_text: SensitiveOutputString });
- * console.log(result.plain_text); // Redacted<string>, logs "<redacted>"
- * ```
- */
-import * as Redacted from "effect/Redacted";
-import * as S from "effect/Schema";
-import * as SchemaTransformation from "effect/SchemaTransformation";
-
-/**
- * Sensitive (input-friendly) - Marks data as sensitive, wrapping in Redacted.
- *
- * Use for **request body** / **input** fields. The decoded TypeScript type is
- * `A | Redacted<A>` so callers can pass either a plain value or a Redacted one.
- * On the wire, plain values are sent through and Redacted values are unwrapped
- * back to their underlying value. Decoded responses are always Redacted.
- *
- * For **output** / **response** fields use {@link SensitiveOutput} instead —
- * its decoded type is strictly `Redacted<A>`, removing the need for callers to
- * narrow / coerce on every read site.
- */
-export const Sensitive = <A>(
-  schema: S.Schema<A>,
-): S.Schema<A | Redacted.Redacted<A>> =>
-  schema
-    .pipe(
-      S.decodeTo(
-        S.Union([S.toType(schema), S.Redacted(S.toType(schema))]),
-        SchemaTransformation.transform({
-          // Decode: wire format -> always wrap in Redacted
-          decode: (a) => Redacted.make(a) as any,
-          // Encode: accept both raw and Redacted -> extract raw value
-          encode: (v) => (Redacted.isRedacted(v) ? Redacted.value(v) : v),
-        }),
-      ),
-    )
-    .annotate({
-      identifier: `Sensitive<${schema.ast.annotations?.identifier ?? "unknown"}>`,
-    });
-
-/**
- * Sensitive string (input-friendly).
- * Wire format: plain string. Decoded TypeScript type: `string | Redacted<string>`.
- * Decoded runtime values are always `Redacted<string>`.
- *
- * Prefer {@link SensitiveOutputString} on response schemas — its static type
- * matches the runtime (strict `Redacted<string>`).
- */
-export const SensitiveString = Sensitive(S.String).annotate({
-  identifier: "SensitiveString",
-});
-
-/**
- * Sensitive nullable string (input-friendly).
- * Wire format: `string | null`. Decoded type: `string | null | Redacted<string>`.
- * Prefer {@link SensitiveOutputNullableString} on response schemas.
- */
-export const SensitiveNullableString = S.NullOr(SensitiveString).annotate({
-  identifier: "SensitiveNullableString",
-});
-
-/**
- * SensitiveOutput - strict variant of {@link Sensitive} for response fields.
- *
- * Decoded TypeScript type is `Redacted<A>` (no union). Wire format is the
- * underlying `A`. Use on response schemas so consumers don't have to narrow
- * `string | Redacted<string>` at every read site.
- */
-export const SensitiveOutput = <A>(
-  schema: S.Schema<A>,
-): S.Schema<Redacted.Redacted<A>> =>
-  schema
-    .pipe(
-      S.decodeTo(
-        S.Redacted(S.toType(schema)),
-        SchemaTransformation.transform({
-          decode: (a) => Redacted.make(a),
-          encode: (v) => Redacted.value(v),
-        }),
-      ),
-    )
-    .annotate({
-      identifier: `SensitiveOutput<${schema.ast.annotations?.identifier ?? "unknown"}>`,
-    });
-
-/**
- * SensitiveOutput string - strict variant of {@link SensitiveString} for
- * response fields. Decoded type is `Redacted<string>`.
- */
-export const SensitiveOutputString = SensitiveOutput(S.String).annotate({
-  identifier: "SensitiveOutputString",
-});
-
-/**
- * SensitiveOutput nullable string - strict variant of
- * {@link SensitiveNullableString} for response fields. Decoded type is
- * `Redacted<string> | null`.
- */
-export const SensitiveOutputNullableString = S.NullOr(
-  SensitiveOutputString,
-).annotate({
-  identifier: "SensitiveOutputNullableString",
-});