@prisma/composer-prisma-cloud 0.1.0-dev.1 → 0.1.0-dev.10

package/dist/streams/index.d.mts

@@ -1,5 +1,6 @@
-import { Contract, DependencyEnd, ModuleNode, SecretNeed } from "@prisma/composer";
-//#region ../../1-prisma-cloud/2-shared-modules/storage/dist/storage-service-CTRaaF2H.d.mts
+import { Contract, DependencyEnd, ModuleNode } from "@prisma/composer";
+import "@standard-schema/spec";
+//#region ../../1-prisma-cloud/2-shared-modules/storage/dist/index-BHsuudro.d.mts
 //#region src/contract.d.ts
 interface S3Config {
   readonly url: string;
@@ -10,38 +11,239 @@ interface S3Config {
 declare const s3Contract: Contract<'s3', S3Config>;
 type S3Contract = typeof s3Contract;
 //#endregion
-//#region ../../1-prisma-cloud/2-shared-modules/streams/dist/streams-service-CBgfFpQj.d.mts
+//#region ../../1-prisma-cloud/2-shared-modules/streams/dist/index-CyjEQsPk.d.mts
 //#region src/contract.d.ts
 interface StreamsConfig {
   readonly url: string;
+  readonly apiKey: string;
 }
-declare const streamsContract: Contract<'streams', StreamsConfig>;
-type StreamsContract = typeof streamsContract;
-/** A consumer's dependency on a durable-streams server. */
-declare function durableStreams(): DependencyEnd<StreamsConfig, typeof streamsContract>;
+/**
+ * One stream's declaration in a `streamsContract` def map. Untyped only in
+ * this slice — carries no event schema. Typed validation
+ * (`streamDef({ event })`) is a recorded follow-up slice; this shape is
+ * deliberately empty rather than half-carrying a schema parameter that does
+ * nothing.
+ */
+interface StreamDef {
+  readonly kind: 'stream-def';
+}
+/** Declares an untyped stream in a `streamsContract` def map. */
+declare function streamDef(): StreamDef;
+type StreamDefs = Record<string, StreamDef>;
+/**
+ * Names the streams a contract transports, each with an optional def:
+ * `streamsContract({ jobs: streamDef(), audit: streamDef() })`. The
+ * `durableStreams(contract)` dependency built from it hydrates to one handle
+ * per declared name.
+ */
+declare function streamsContract<D extends StreamDefs>(defs: D): Contract<'streams', D>;
+/** The type of a `streamsContract(defs)` value. */
+type StreamsContract<D extends StreamDefs = StreamDefs> = Contract<'streams', D>;
+/** The handles a `durableStreams(contract)` dependency hydrates to: one per declared stream name. */
+type StreamHandles<D extends StreamDefs> = { readonly [K in keyof D]: StreamHandle; };
+/**
+ * A consumer's dependency on a durable-streams server. Given a
+ * `streamsContract(defs)`, hydrates to one handle per declared stream name —
+ * the handle owns the name, so no call site names it again. Called with no
+ * argument, hydrates to a `StreamsClient` for dynamic stream names (e.g.
+ * per-tenant streams) — the `postgres()` parity: the same lifecycle
+ * ownership, the name is data rather than a wiring-time declaration.
+ */
+declare function durableStreams<D extends StreamDefs>(contract: Contract<'streams', D>): DependencyEnd<StreamHandles<D>, Contract<'streams', StreamDefs>>;
+declare function durableStreams(): DependencyEnd<StreamsClient, Contract<'streams', StreamDefs>>;
 //#endregion
-//#region src/streams-service.d.ts
-declare function streamsService(): import("@prisma/composer").RunnableServiceNode<{
-  store: import("@prisma/composer").DependencyEnd<S3Config, import("@prisma/composer").Contract<"s3", S3Config>>;
-}, Record<never, never> & {
-  readonly port: import("@prisma/composer").ConfigParam<import("@standard-schema/spec").StandardSchemaV1<number, number>>;
-}, {
-  streams: import("@prisma/composer").Contract<"streams", StreamsConfig>;
-}, {
-  apiKey: import("@prisma/composer").SecretNeed;
-}>;
+//#region src/client.d.ts
+/** A catch-up read: the events from the requested offset, and the cursor to resume from. */
+interface StreamsReadResult<T> {
+  readonly events: readonly T[];
+  /** Opaque resume cursor (the protocol's `stream-next-offset`); feed it back as `offset`. */
+  readonly nextOffset: string;
+}
+/** One live long-poll delivery, or a timeout with nothing new. */
+interface StreamsTailResult<T> {
+  readonly events: readonly T[];
+  readonly nextOffset: string;
+  readonly timedOut: boolean;
+}
+/**
+ * The transport a consumer's `durableStreams()` binding hydrates to (bare
+ * form) — holds the base URL, the bearer header, and the per-stream write
+ * handles a batched append needs. `stream(name)` is the client's whole
+ * public surface: a dynamic streams consumer names a stream by calling it,
+ * never by any other method here.
+ */
+declare class StreamsClient {
+  private readonly base;
+  private readonly headers;
+  private readonly writers;
+  private readonly handles;
+  constructor(config: StreamsConfig);
+  /** One handle per stream name, memoized so its ensure-create state survives repeat calls. */
+  stream(name: string): StreamHandle;
+  private writer;
+  /** Creates the stream (idempotent: an existing stream of any content type is success). Used by `StreamHandle`'s ensure-create. */
+  create(name: string): Promise<void>;
+  /**
+   * Appends one JSON event. NEVER retried beyond `StreamHandle`'s one-shot
+   * 404 heal: the protocol has no idempotency key, so a failed request is
+   * indistinguishable from one that applied — the caller retries, because
+   * only it knows whether a duplicate is acceptable.
+   */
+  append(name: string, event: unknown): Promise<void>;
+  /** Reads the stream from `offset` (default: the beginning) to the current head. */
+  read<T = unknown>(name: string, opts?: {
+    offset?: string;
+  }): Promise<StreamsReadResult<T>>;
+  /**
+   * Waits for the next live delivery after `offset` (default: the current
+   * head), via long-poll — SSE cannot traverse the Compute ingress (PRO-218).
+   * Resolves with the delivered events, or `timedOut: true` after `timeoutMs`
+   * (default 20s) with nothing new.
+   */
+  tail<T = unknown>(name: string, opts?: {
+    offset?: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+  }): Promise<StreamsTailResult<T>>;
+}
+/**
+ * One stream's handle — the name and the ensure-create memo. Everything a
+ * `durableStreams(contract)` handle or a `durableStreams()` client's
+ * `stream(name)` result exposes; no call site passes a name again.
+ *
+ * Owns the lifecycle the app used to hand-roll: the first operation creates
+ * the stream (memoized here; upstream create is already ensure-style, so a
+ * racing second instance is harmless — using a stream is sufficient to
+ * create it), and a 404 on any operation heals by dropping the memo,
+ * re-creating, and retrying that operation once. A 404 is generated INSTEAD
+ * OF a write at every layer, so it proves nothing was applied — retrying
+ * once cannot duplicate an event, even an append. Ambiguous failures (socket
+ * closes, 502/504) never match `isStreamNotFound` and surface raw.
+ */
+declare class StreamHandle {
+  private readonly name;
+  private readonly transport;
+  private ensured;
+  constructor(name: string, transport: StreamsClient);
+  private ensureCreate;
+  private withHeal;
+  /**
+   * Appends one JSON event. NEVER retried beyond the one-shot 404 heal above:
+   * the protocol has no idempotency key, so a failed request is
+   * indistinguishable from one that applied — the caller retries, because
+   * only it knows whether a duplicate is acceptable.
+   */
+  append(event: unknown): Promise<void>;
+  /** Reads the stream from `offset` (default: the beginning) to the current head. */
+  read<T = unknown>(opts?: {
+    offset?: string;
+  }): Promise<StreamsReadResult<T>>;
+  /**
+   * Waits for the next live delivery after `offset` (default: the current
+   * head), via long-poll. Resolves with the delivered events, or
+   * `timedOut: true` after `timeoutMs` (default 20s) with nothing new.
+   */
+  tail<T = unknown>(opts?: {
+    offset?: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+  }): Promise<StreamsTailResult<T>>;
+}
 //#endregion
-//#region ../../1-prisma-cloud/2-shared-modules/streams/dist/index.d.mts
 //#region src/streams-module.d.ts
 declare function streams(opts?: {
   name?: string;
 }): ModuleNode<{
   store: DependencyEnd<S3Config, S3Contract>;
 }, {
-  streams: typeof streamsContract;
+  streams: Contract<'streams', StreamDefs>;
+}, Record<never, never>>;
+//#endregion
+//#region ../../../../node_modules/@standard-schema/spec/dist/index.d.ts
+/** The Standard Typed interface. This is a base type extended by other specs. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /** The Standard Typed properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The Standard Typed types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Typed. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Typed. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** A falsy value for `issues` indicates success. */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+//#endregion
+//#region src/exports/streams-service.d.ts
+declare function streamsService(): import("@prisma/composer").RunnableServiceNode<{
+  store: import("@prisma/composer").DependencyEnd<S3Config, import("@prisma/composer").Contract<"s3", S3Config>>;
+}, Record<never, never> & {
+  readonly port: import("@prisma/composer").ConfigParam<StandardSchemaV1<number, number>>;
 }, {
-  apiKey: SecretNeed;
-}>;
+  streams: import("@prisma/composer").Contract<"streams", StreamDefs>;
+}, Record<never, never>>;
 //#endregion
-export { type StreamsConfig, type StreamsContract, durableStreams, streams, streamsContract, streamsService };
+export { type StreamDef, type StreamDefs, StreamHandle, type StreamHandles, StreamsClient, type StreamsConfig, type StreamsContract, type StreamsReadResult, type StreamsTailResult, durableStreams, streamDef, streams, streamsContract, streamsService };
 //# sourceMappingURL=index.d.mts.map