@hatchet-dev/typescript-sdk 1.37.0 → 1.39.0

package/core/features/streams.js

@@ -1,10 +1,82 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamsClient = void 0;
-/** Publishes stream chunks from a task run, the way `ctx.putStream` does from a worker. */
+exports.StreamsClient = exports.MAX_TRACKED_TOPICS = exports.MAX_STREAM_MESSAGE_BYTES = void 0;
+const connect_1 = require("@connectrpc/connect");
+const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
+const abort_error_1 = require("../../util/abort-error");
+/**
+ * The largest payload one `publish` carries: the engine's limit for a payload sent inline
+ * (`MaxStreamMessagePayloadBytes`). The Node client uploads larger payloads over its REST
+ * client first; this client has none, so it rejects them.
+ */
+exports.MAX_STREAM_MESSAGE_BYTES = 4 * 1024 * 1024 - 5 * 1024;
+/**
+ * How many (namespace, topic) producers the client remembers. A topic past the cap starts
+ * over with a new producer id, which the engine orders after the old one, so correctness
+ * does not depend on the cap; it only bounds memory for clients that publish to many
+ * short-lived topics.
+ */
+exports.MAX_TRACKED_TOPICS = 1024;
+function isEventsService(deps) {
+    return typeof deps.putStreamEvent === 'function';
+}
+/** The engine stored nothing, so the producer's sequence number is still unused. */
+function publishRejectedBeforeStoring(err) {
+    return (err instanceof connect_1.ConnectError &&
+        (err.code === connect_1.Code.InvalidArgument ||
+            err.code === connect_1.Code.ResourceExhausted ||
+            err.code === connect_1.Code.Unauthenticated ||
+            err.code === connect_1.Code.PermissionDenied));
+}
+/**
+ * Task run streams and durable stream topics.
+ *
+ * `put` publishes a chunk on a task run's stream, the way `ctx.putStream` does from a worker.
+ * `publish`, `reset` and `topicMetadata` are the Node client's durable topic calls
+ * (`hatchet.streams`), with the same names and options. `events()` is not here: it is a
+ * server stream, which the unary transport does not carry. Read a topic with the Node client
+ * (`hatchet.streams.events(topic)`), or from a serverless task over the operator socket once
+ * the operator relays the subscription.
+ */
 class StreamsClient {
-    constructor(rpc) {
-        this.rpc = rpc;
+    /**
+     * Takes the events and durable streams services, or only the events service, which
+     * serves `put` and leaves the durable stream calls unavailable.
+     */
+    constructor(deps) {
+        /** Per (namespace, topic); the sequence number only advances after a publish succeeds. */
+        this.producers = new Map();
+        /**
+         * Serializes publishes per (namespace, topic) so two never share a sequence number. The
+         * stored promise always resolves, so one failure does not block later calls.
+         */
+        this.publishChains = new Map();
+        if (isEventsService(deps)) {
+            this.events = deps;
+            this.streams = undefined;
+        }
+        else {
+            this.events = deps.events;
+            this.streams = deps.streams;
+        }
+    }
+    durable() {
+        if (!this.streams) {
+            throw new hatchet_error_1.default('durable streams are unavailable: this StreamsClient was built with the events service only; build it with { events, streams }');
+        }
+        return this.streams;
     }
     /**
      * Publishes one chunk on a task run's stream. `index` orders chunks that are published
@@ -12,12 +84,141 @@ class StreamsClient {
      */
     put(taskRunExternalId, data, index) {
         const message = typeof data === 'string' ? new TextEncoder().encode(data) : data;
-        return this.rpc.putStreamEvent({
+        return this.events.putStreamEvent({
             taskRunExternalId,
             createdAt: new Date(),
             message,
             eventIndex: index,
         });
     }
+    /**
+     * Publishes a message to a durable topic and resolves once it is stored. A client's
+     * messages to a topic are delivered in the order `publish` was called. A payload over
+     * `MAX_STREAM_MESSAGE_BYTES` rejects with a `HatchetError` before anything is sent.
+     * @param topic - the topic to publish to
+     * @param message - the message payload
+     * @param options - optional namespace override and abort signal
+     */
+    publish(topic, message, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const payload = typeof message === 'string' ? new TextEncoder().encode(message) : message;
+            const namespace = (_a = options === null || options === void 0 ? void 0 : options.namespace) !== null && _a !== void 0 ? _a : '';
+            const key = `${namespace}\0${topic}`;
+            if (payload.byteLength > exports.MAX_STREAM_MESSAGE_BYTES) {
+                throw new hatchet_error_1.default(`stream payload is ${payload.byteLength} bytes, over the ${exports.MAX_STREAM_MESSAGE_BYTES}-byte limit of one publish; publish it from the Node client, which uploads larger payloads`);
+            }
+            const signal = options === null || options === void 0 ? void 0 : options.signal;
+            const previous = (_b = this.publishChains.get(key)) !== null && _b !== void 0 ? _b : Promise.resolve();
+            const publishPromise = previous.then(() => {
+                // An abort while this publish waited behind earlier ones sends nothing.
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                    throw new abort_error_1.AbortError();
+                }
+                return this.publishOrdered(key, namespace, topic, payload, signal);
+            });
+            const chain = publishPromise
+                .catch(() => { })
+                .then(() => {
+                // The topic's queue is idle once its last publish settled.
+                if (this.publishChains.get(key) === chain) {
+                    this.publishChains.delete(key);
+                }
+            });
+            this.publishChains.set(key, chain);
+            if (!signal) {
+                return publishPromise;
+            }
+            // The caller is released as soon as its signal aborts, while the queue keeps its order
+            // and the aborted publish is skipped when its turn comes.
+            return new Promise((resolve, reject) => {
+                const onAbort = () => reject(new abort_error_1.AbortError());
+                if (signal.aborted) {
+                    onAbort();
+                    return;
+                }
+                signal.addEventListener('abort', onAbort, { once: true });
+                publishPromise.then(resolve, reject).finally(() => {
+                    signal.removeEventListener('abort', onAbort);
+                });
+            });
+        });
+    }
+    /**
+     * Describes a topic's retained messages. Rejects with a `ConnectError` of code `NotFound`
+     * for a topic nothing was published to.
+     * @param topic - the topic to describe
+     * @param options - optional namespace override and abort signal
+     */
+    topicMetadata(topic, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const res = yield this.durable().getTopicMetadata({ namespace: (_a = options === null || options === void 0 ? void 0 : options.namespace) !== null && _a !== void 0 ? _a : '', topic }, { signal: options === null || options === void 0 ? void 0 : options.signal });
+            return {
+                namespace: res.namespace,
+                topic: res.topic,
+                tenantId: res.tenantId,
+                messageCount: res.messageCount,
+                latestCursor: res.latestCursor,
+                lastPublishedAt: res.lastPublishedAt,
+            };
+        });
+    }
+    /**
+     * Makes `events()` calls without a cursor start after the topic's latest message. Readers
+     * already iterating, and any call with a cursor, are unaffected.
+     * @param topic - the topic to reset
+     * @param options - optional namespace override and abort signal
+     */
+    reset(topic, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield this.durable().reset({ namespace: (_a = options === null || options === void 0 ? void 0 : options.namespace) !== null && _a !== void 0 ? _a : '', topic }, { signal: options === null || options === void 0 ? void 0 : options.signal });
+        });
+    }
+    publishOrdered(key_1, namespace_1, topic_1, payload_1, signal_1) {
+        return __awaiter(this, arguments, void 0, function* (key, namespace, topic, payload, signal, retryGap = true) {
+            const streams = this.durable();
+            let producer = this.producers.get(key);
+            if (producer) {
+                // re-inserting keeps the map in last-use order for the eviction below
+                this.producers.delete(key);
+            }
+            else {
+                producer = { producerId: crypto.randomUUID(), seq: 0 };
+            }
+            this.producers.set(key, producer);
+            while (this.producers.size > exports.MAX_TRACKED_TOPICS) {
+                const oldest = this.producers.keys().next().value;
+                if (oldest === undefined) {
+                    break;
+                }
+                this.producers.delete(oldest);
+            }
+            try {
+                yield streams.publish({
+                    namespace,
+                    topic,
+                    payload,
+                    producerId: producer.producerId,
+                    producerSeq: producer.seq,
+                }, { signal });
+            }
+            catch (err) {
+                // The message may still land, and a different payload under its sequence number
+                // would be dropped as a duplicate, so the next publish comes from a new producer.
+                if (!publishRejectedBeforeStoring(err)) {
+                    this.producers.set(key, { producerId: crypto.randomUUID(), seq: 0 });
+                }
+                // A gap stored nothing (the watermark passed cursor retention, say): resend as the
+                // new producer.
+                if (retryGap && err instanceof connect_1.ConnectError && err.code === connect_1.Code.FailedPrecondition) {
+                    return this.publishOrdered(key, namespace, topic, payload, signal, false);
+                }
+                throw err;
+            }
+            producer.seq += 1;
+        });
+    }
 }
 exports.StreamsClient = StreamsClient;

package/core/index.d.ts

@@ -1,7 +1,8 @@
 /**
  * The core entry point: the application client for runtimes without gRPC. It triggers runs,
- * pushes events, waits for results by polling and manages workflows over unary Connect calls
- * on a fetch transport, and it is configured from an explicit object only.
+ * pushes events, waits for results by polling, publishes to durable streams and manages
+ * workflows over unary Connect calls on a fetch transport, and it is configured from an
+ * explicit object only.
  *
  * Nothing exported here imports from Node. `scripts/check-edge-entry.mjs` bundles this module
  * for a browser-like target and fails the build if a Node builtin, `axios` or a gRPC package
@@ -24,14 +25,15 @@ export { WorkflowRunRef, INITIAL_POLL_INTERVAL_MS, MAX_POLL_INTERVAL_MS } from '
 export type { RunRefClient } from './run-ref';
 export { toRunDetail, parseTaskOutput, runStatusToJSON } from './run-detail';
 export { ConsoleLogger, consoleLogger } from './logger';
-export type { CallOptions, CancelRunOpts, CoreClientConfig, CreateRateLimitOpts, DesiredWorkerLabelOpt, EventWithMetadata, LogConstructor, PushEventOptions, ReplayRunOpts, ResultOptions, RunDetail, RunFilter, RunFilterBase, TaskRunDetail, TriggerRun, TriggerRunOptions, } from './types';
+export type { CallOptions, CancelRunOpts, CoreClientConfig, CreateRateLimitOpts, DesiredWorkerLabelOpt, EventWithMetadata, LogConstructor, PushEventOptions, ReplayRunOpts, ResultOptions, RunDetail, RunFilter, RunFilterBase, StreamCallOptions, StreamTopicMetadata, TaskRunDetail, TriggerRun, TriggerRunOptions, } from './types';
 export { EventsClient } from './features/events';
 export { RunsClient } from './features/runs';
 export { WorkflowsClient } from './features/workflows';
 export { RateLimitsClient } from './features/rate-limits';
 export { LogsClient, MAX_LOG_LINE_CHARS } from './features/logs';
 export type { PutLogOptions } from './features/logs';
-export { StreamsClient } from './features/streams';
+export { StreamsClient, MAX_STREAM_MESSAGE_BYTES } from './features/streams';
+export type { StreamsClientDeps } from './features/streams';
 export { createFetchTransport, limitMessageSizes, resolveServerUrl, type FetchTlsConfig, type FetchTransportOptions, type MessageSizeLimits, } from '../clients/transport/fetch-transport';
 export { createAuthInterceptor, DEFAULT_MAX_MESSAGE_BYTES, type Transport, } from '../clients/transport/transport';
 export { LogLevel } from '../clients/event/rpc';
@@ -40,7 +42,9 @@ export type { RunManyOpt, RunOpts } from '../v1/declaration';
 export { RateLimitDuration } from '../protoc/workflows/workflows';
 export { WorkerLabelComparator } from '../protoc/v1/shared/trigger';
 export { V1TaskStatus } from '../clients/rest/generated/data-contracts';
-export { default as HatchetError, getErrorMessage, toHatchetError, } from '../util/errors/hatchet-error';
+import HatchetError from '../util/errors/hatchet-error';
+export { HatchetError };
+export { getErrorMessage, toHatchetError } from '../util/errors/hatchet-error';
 export { IdempotencyCollisionError } from '../util/errors/idempotency-collision-error';
 export { BulkTriggerIdempotencyCollisionError } from '../util/errors/bulk-trigger-idempotency-collision-error';
 export { BulkTriggerPartialError } from '../util/errors/bulk-trigger-partial-error';

package/core/index.js

@@ -1,8 +1,9 @@
 "use strict";
 /**
  * The core entry point: the application client for runtimes without gRPC. It triggers runs,
- * pushes events, waits for results by polling and manages workflows over unary Connect calls
- * on a fetch transport, and it is configured from an explicit object only.
+ * pushes events, waits for results by polling, publishes to durable streams and manages
+ * workflows over unary Connect calls on a fetch transport, and it is configured from an
+ * explicit object only.
  *
  * Nothing exported here imports from Node. `scripts/check-edge-entry.mjs` bundles this module
  * for a browser-like target and fails the build if a Node builtin, `axios` or a gRPC package
@@ -21,7 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAbortError = exports.AbortError = exports.BulkTriggerPartialError = exports.BulkTriggerIdempotencyCollisionError = exports.IdempotencyCollisionError = exports.toHatchetError = exports.getErrorMessage = exports.HatchetError = exports.V1TaskStatus = exports.WorkerLabelComparator = exports.RateLimitDuration = exports.Priority = exports.LogLevel = exports.DEFAULT_MAX_MESSAGE_BYTES = exports.createAuthInterceptor = exports.resolveServerUrl = exports.limitMessageSizes = exports.createFetchTransport = exports.StreamsClient = exports.MAX_LOG_LINE_CHARS = exports.LogsClient = exports.RateLimitsClient = exports.WorkflowsClient = exports.RunsClient = exports.EventsClient = exports.consoleLogger = exports.ConsoleLogger = exports.runStatusToJSON = exports.parseTaskOutput = exports.toRunDetail = exports.MAX_POLL_INTERVAL_MS = exports.INITIAL_POLL_INTERVAL_MS = exports.WorkflowRunRef = exports.Hatchet = exports.HatchetCore = exports.CORE_ENTRY_VERSION = void 0;
+exports.isAbortError = exports.AbortError = exports.BulkTriggerPartialError = exports.BulkTriggerIdempotencyCollisionError = exports.IdempotencyCollisionError = exports.toHatchetError = exports.getErrorMessage = exports.HatchetError = exports.V1TaskStatus = exports.WorkerLabelComparator = exports.RateLimitDuration = exports.Priority = exports.LogLevel = exports.DEFAULT_MAX_MESSAGE_BYTES = exports.createAuthInterceptor = exports.resolveServerUrl = exports.limitMessageSizes = exports.createFetchTransport = exports.MAX_STREAM_MESSAGE_BYTES = exports.StreamsClient = exports.MAX_LOG_LINE_CHARS = exports.LogsClient = exports.RateLimitsClient = exports.WorkflowsClient = exports.RunsClient = exports.EventsClient = exports.consoleLogger = exports.ConsoleLogger = exports.runStatusToJSON = exports.parseTaskOutput = exports.toRunDetail = exports.MAX_POLL_INTERVAL_MS = exports.INITIAL_POLL_INTERVAL_MS = exports.WorkflowRunRef = exports.Hatchet = exports.HatchetCore = exports.CORE_ENTRY_VERSION = void 0;
 /** Bumped whenever the surface exported from this entry changes incompatibly. */
 exports.CORE_ENTRY_VERSION = 1;
 var client_1 = require("./client");
@@ -52,6 +53,7 @@ Object.defineProperty(exports, "LogsClient", { enumerable: true, get: function (
 Object.defineProperty(exports, "MAX_LOG_LINE_CHARS", { enumerable: true, get: function () { return logs_1.MAX_LOG_LINE_CHARS; } });
 var streams_1 = require("./features/streams");
 Object.defineProperty(exports, "StreamsClient", { enumerable: true, get: function () { return streams_1.StreamsClient; } });
+Object.defineProperty(exports, "MAX_STREAM_MESSAGE_BYTES", { enumerable: true, get: function () { return streams_1.MAX_STREAM_MESSAGE_BYTES; } });
 // Transport
 var fetch_transport_1 = require("../clients/transport/fetch-transport");
 Object.defineProperty(exports, "createFetchTransport", { enumerable: true, get: function () { return fetch_transport_1.createFetchTransport; } });
@@ -71,10 +73,14 @@ var trigger_1 = require("../protoc/v1/shared/trigger");
 Object.defineProperty(exports, "WorkerLabelComparator", { enumerable: true, get: function () { return trigger_1.WorkerLabelComparator; } });
 var data_contracts_1 = require("../clients/rest/generated/data-contracts");
 Object.defineProperty(exports, "V1TaskStatus", { enumerable: true, get: function () { return data_contracts_1.V1TaskStatus; } });
-var hatchet_error_1 = require("../util/errors/hatchet-error");
-Object.defineProperty(exports, "HatchetError", { enumerable: true, get: function () { return __importDefault(hatchet_error_1).default; } });
-Object.defineProperty(exports, "getErrorMessage", { enumerable: true, get: function () { return hatchet_error_1.getErrorMessage; } });
-Object.defineProperty(exports, "toHatchetError", { enumerable: true, get: function () { return hatchet_error_1.toHatchetError; } });
+// HatchetError is imported and re-exported by name rather than as `default as`: tsc emits a
+// getter for the latter that Node's CommonJS export detection cannot see, which hides the name
+// from ESM importers of this entry.
+const hatchet_error_1 = __importDefault(require("../util/errors/hatchet-error"));
+exports.HatchetError = hatchet_error_1.default;
+var hatchet_error_2 = require("../util/errors/hatchet-error");
+Object.defineProperty(exports, "getErrorMessage", { enumerable: true, get: function () { return hatchet_error_2.getErrorMessage; } });
+Object.defineProperty(exports, "toHatchetError", { enumerable: true, get: function () { return hatchet_error_2.toHatchetError; } });
 var idempotency_collision_error_1 = require("../util/errors/idempotency-collision-error");
 Object.defineProperty(exports, "IdempotencyCollisionError", { enumerable: true, get: function () { return idempotency_collision_error_1.IdempotencyCollisionError; } });
 var bulk_trigger_idempotency_collision_error_1 = require("../util/errors/bulk-trigger-idempotency-collision-error");

package/core/types.d.ts

@@ -180,3 +180,23 @@ export interface ResultOptions {
     /** Rejects with an `AbortError` when the signal fires. */
     signal?: AbortSignal;
 }
+/** Per-call options of the durable stream calls; the same shape on the core and Node clients. */
+export type StreamCallOptions = {
+    /** The topic's namespace; the empty namespace when omitted. */
+    namespace?: string;
+    /** Resumes an `events()` iteration right after this message. */
+    cursor?: string;
+    /** Ends an `events()` iteration cleanly, without throwing; aborts a unary call. */
+    signal?: AbortSignal;
+};
+/** What a durable stream topic retains; counts and the latest message cover the tenant's retention. */
+export type StreamTopicMetadata = {
+    namespace: string;
+    topic: string;
+    tenantId: string;
+    messageCount: number;
+    /** Resumes `events()` after the newest retained message; undefined when none is retained. */
+    latestCursor?: string;
+    /** When the newest retained message was stored; undefined when none is retained. */
+    lastPublishedAt?: Date;
+};

package/dist/check-core-esm-exports.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+// Verifies that every export of the built core entry is visible to an ESM importer under Node:
+// the entry is CommonJS, and Node derives its named exports statically, so a re-export written
+// in a form that detection misses (a getter over a default import) vanishes for `import { X }`.
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { resolve } from 'node:path';
+
+const entry = resolve('dist/core/index.js');
+const cjs = createRequire(import.meta.url)(entry);
+const esm = await import(pathToFileURL(entry).href);
+const missing = Object.keys(cjs).filter((name) => name !== '__esModule' && !(name in esm));
+
+if (missing.length > 0) {
+  console.error(`core entry exports hidden from ESM importers: ${missing.join(', ')}`);
+  process.exit(1);
+}
+
+console.log(`core entry: ${Object.keys(cjs).length} exports visible to ESM importers`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.37.0",
+  "version": "1.39.0",
   "engines": {
     "node": ">=20"
   },
@@ -238,7 +238,7 @@
     "tsc:build": "pnpm run dump-version && tsc && resolve-tspaths",
     "test:unit": "jest --testMatch='**/*.test.ts'",
     "check:edge": "pnpm run tsc:build && node scripts/check-edge-entry.mjs",
-    "check:core": "pnpm run tsc:build && node scripts/check-edge-entry.mjs dist/core/index.js --forbid axios,nice-grpc,@grpc/grpc-js,@connectrpc/connect-node,long,protobufjs,yaml",
+    "check:core": "pnpm run tsc:build && node scripts/check-edge-entry.mjs dist/core/index.js --forbid axios,nice-grpc,@grpc/grpc-js,@connectrpc/connect-node,long,protobufjs,yaml && node scripts/check-core-esm-exports.mjs",
     "check:exports": "pnpm run tsc:build && node scripts/check-exports.mjs",
     "test:e2e": "jest --config jest.e2e.config.ts --silent --forceExit --runInBand",
     "test:unit:watch": "jest --testMatch='**/*.test.ts' --watch",

package/protoc/v1/streams.d.ts

@@ -47,6 +47,12 @@ export interface StreamTopicMetadata {
     /** when the newest retained message was stored; unset when none is retained */
     lastPublishedAt: Date | undefined;
 }
+export interface ResetStreamTopicRequest {
+    namespace: string;
+    topic: string;
+}
+export interface ResetStreamTopicResponse {
+}
 export declare const PublishStreamMessageRequest: MessageFns<PublishStreamMessageRequest>;
 export declare const PublishStreamMessageResponse: MessageFns<PublishStreamMessageResponse>;
 export declare const SubscribeStreamRequest: MessageFns<SubscribeStreamRequest>;
@@ -54,6 +60,8 @@ export declare const StreamMessage: MessageFns<StreamMessage>;
 export declare const StreamEntry: MessageFns<StreamEntry>;
 export declare const GetStreamTopicMetadataRequest: MessageFns<GetStreamTopicMetadataRequest>;
 export declare const StreamTopicMetadata: MessageFns<StreamTopicMetadata>;
+export declare const ResetStreamTopicRequest: MessageFns<ResetStreamTopicRequest>;
+export declare const ResetStreamTopicResponse: MessageFns<ResetStreamTopicResponse>;
 export type V1StreamsDefinition = typeof V1StreamsDefinition;
 export declare const V1StreamsDefinition: {
     readonly name: "V1Streams";
@@ -83,17 +91,27 @@ export declare const V1StreamsDefinition: {
             readonly responseStream: false;
             readonly options: {};
         };
+        readonly reset: {
+            readonly name: "Reset";
+            readonly requestType: typeof ResetStreamTopicRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof ResetStreamTopicResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
     };
 };
 export interface V1StreamsServiceImplementation<CallContextExt = {}> {
     publish(request: PublishStreamMessageRequest, context: CallContext & CallContextExt): Promise<DeepPartial<PublishStreamMessageResponse>>;
     subscribe(request: SubscribeStreamRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<StreamMessage>>;
     getTopicMetadata(request: GetStreamTopicMetadataRequest, context: CallContext & CallContextExt): Promise<DeepPartial<StreamTopicMetadata>>;
+    reset(request: ResetStreamTopicRequest, context: CallContext & CallContextExt): Promise<DeepPartial<ResetStreamTopicResponse>>;
 }
 export interface V1StreamsClient<CallOptionsExt = {}> {
     publish(request: DeepPartial<PublishStreamMessageRequest>, options?: CallOptions & CallOptionsExt): Promise<PublishStreamMessageResponse>;
     subscribe(request: DeepPartial<SubscribeStreamRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<StreamMessage>;
     getTopicMetadata(request: DeepPartial<GetStreamTopicMetadataRequest>, options?: CallOptions & CallOptionsExt): Promise<StreamTopicMetadata>;
+    reset(request: DeepPartial<ResetStreamTopicRequest>, options?: CallOptions & CallOptionsExt): Promise<ResetStreamTopicResponse>;
 }
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {

package/protoc/v1/streams.js

@@ -5,7 +5,7 @@
 //   protoc               v3.19.1
 // source: v1/streams.proto
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.V1StreamsDefinition = exports.StreamTopicMetadata = exports.GetStreamTopicMetadataRequest = exports.StreamEntry = exports.StreamMessage = exports.SubscribeStreamRequest = exports.PublishStreamMessageResponse = exports.PublishStreamMessageRequest = exports.protobufPackage = void 0;
+exports.V1StreamsDefinition = exports.ResetStreamTopicResponse = exports.ResetStreamTopicRequest = exports.StreamTopicMetadata = exports.GetStreamTopicMetadataRequest = exports.StreamEntry = exports.StreamMessage = exports.SubscribeStreamRequest = exports.PublishStreamMessageResponse = exports.PublishStreamMessageRequest = exports.protobufPackage = void 0;
 /* eslint-disable */
 const wire_1 = require("@bufbuild/protobuf/wire");
 const timestamp_1 = require("../google/protobuf/timestamp");
@@ -694,6 +694,112 @@ exports.StreamTopicMetadata = {
         return message;
     },
 };
+function createBaseResetStreamTopicRequest() {
+    return { namespace: '', topic: '' };
+}
+exports.ResetStreamTopicRequest = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.namespace !== '') {
+            writer.uint32(10).string(message.namespace);
+        }
+        if (message.topic !== '') {
+            writer.uint32(18).string(message.topic);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseResetStreamTopicRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.namespace = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.topic = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            namespace: isSet(object.namespace) ? globalThis.String(object.namespace) : '',
+            topic: isSet(object.topic) ? globalThis.String(object.topic) : '',
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.namespace !== '') {
+            obj.namespace = message.namespace;
+        }
+        if (message.topic !== '') {
+            obj.topic = message.topic;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.ResetStreamTopicRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = createBaseResetStreamTopicRequest();
+        message.namespace = (_a = object.namespace) !== null && _a !== void 0 ? _a : '';
+        message.topic = (_b = object.topic) !== null && _b !== void 0 ? _b : '';
+        return message;
+    },
+};
+function createBaseResetStreamTopicResponse() {
+    return {};
+}
+exports.ResetStreamTopicResponse = {
+    encode(_, writer = new wire_1.BinaryWriter()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseResetStreamTopicResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(_) {
+        return {};
+    },
+    toJSON(_) {
+        const obj = {};
+        return obj;
+    },
+    create(base) {
+        return exports.ResetStreamTopicResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(_) {
+        const message = createBaseResetStreamTopicResponse();
+        return message;
+    },
+};
 exports.V1StreamsDefinition = {
     name: 'V1Streams',
     fullName: 'v1.V1Streams',
@@ -722,6 +828,14 @@ exports.V1StreamsDefinition = {
             responseStream: false,
             options: {},
         },
+        reset: {
+            name: 'Reset',
+            requestType: exports.ResetStreamTopicRequest,
+            requestStream: false,
+            responseType: exports.ResetStreamTopicResponse,
+            responseStream: false,
+            options: {},
+        },
     },
 };
 function bytesFromBase64(b64) {

package/protoc-es/v1/streams_pb.d.ts

@@ -181,6 +181,33 @@ export type StreamTopicMetadata = Message<"v1.StreamTopicMetadata"> & {
  * Use `create(StreamTopicMetadataSchema)` to create a new message.
  */
 export declare const StreamTopicMetadataSchema: GenMessage<StreamTopicMetadata>;
+/**
+ * @generated from message v1.ResetStreamTopicRequest
+ */
+export type ResetStreamTopicRequest = Message<"v1.ResetStreamTopicRequest"> & {
+    /**
+     * @generated from field: string namespace = 1;
+     */
+    namespace: string;
+    /**
+     * @generated from field: string topic = 2;
+     */
+    topic: string;
+};
+/**
+ * Describes the message v1.ResetStreamTopicRequest.
+ * Use `create(ResetStreamTopicRequestSchema)` to create a new message.
+ */
+export declare const ResetStreamTopicRequestSchema: GenMessage<ResetStreamTopicRequest>;
+/**
+ * @generated from message v1.ResetStreamTopicResponse
+ */
+export type ResetStreamTopicResponse = Message<"v1.ResetStreamTopicResponse"> & {};
+/**
+ * Describes the message v1.ResetStreamTopicResponse.
+ * Use `create(ResetStreamTopicResponseSchema)` to create a new message.
+ */
+export declare const ResetStreamTopicResponseSchema: GenMessage<ResetStreamTopicResponse>;
 /**
  * @generated from service v1.V1Streams
  */
@@ -209,4 +236,12 @@ export declare const V1Streams: GenService<{
         input: typeof GetStreamTopicMetadataRequestSchema;
         output: typeof StreamTopicMetadataSchema;
     };
+    /**
+     * @generated from rpc v1.V1Streams.Reset
+     */
+    reset: {
+        methodKind: "unary";
+        input: typeof ResetStreamTopicRequestSchema;
+        output: typeof ResetStreamTopicResponseSchema;
+    };
 }>;

package/protoc-es/v1/streams_pb.js

@@ -3,13 +3,13 @@
 // @generated from file v1/streams.proto (package v1, syntax proto3)
 /* eslint-disable */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.V1Streams = exports.StreamTopicMetadataSchema = exports.GetStreamTopicMetadataRequestSchema = exports.StreamEntrySchema = exports.StreamMessageSchema = exports.SubscribeStreamRequestSchema = exports.PublishStreamMessageResponseSchema = exports.PublishStreamMessageRequestSchema = exports.file_v1_streams = void 0;
+exports.V1Streams = exports.ResetStreamTopicResponseSchema = exports.ResetStreamTopicRequestSchema = exports.StreamTopicMetadataSchema = exports.GetStreamTopicMetadataRequestSchema = exports.StreamEntrySchema = exports.StreamMessageSchema = exports.SubscribeStreamRequestSchema = exports.PublishStreamMessageResponseSchema = exports.PublishStreamMessageRequestSchema = exports.file_v1_streams = void 0;
 const codegenv2_1 = require("@bufbuild/protobuf/codegenv2");
 const wkt_1 = require("@bufbuild/protobuf/wkt");
 /**
  * Describes the file v1/streams.proto.
  */
-exports.file_v1_streams = (0, codegenv2_1.fileDesc)("ChB2MS9zdHJlYW1zLnByb3RvEgJ2MSKQAQobUHVibGlzaFN0cmVhbU1lc3NhZ2VSZXF1ZXN0EhEKCW5hbWVzcGFjZRgBIAEoCRINCgV0b3BpYxgCIAEoCRIPCgdwYXlsb2FkGAMgASgMEhMKC3Byb2R1Y2VyX2lkGAQgASgJEhQKDHByb2R1Y2VyX3NlcRgFIAEoAxITCgtwYXlsb2FkX3JlZhgGIAEoCSIeChxQdWJsaXNoU3RyZWFtTWVzc2FnZVJlc3BvbnNlIloKFlN1YnNjcmliZVN0cmVhbVJlcXVlc3QSEQoJbmFtZXNwYWNlGAEgASgJEg0KBXRvcGljGAIgASgJEhMKBmN1cnNvchgDIAEoCUgAiAEBQgkKB19jdXJzb3IiUQoNU3RyZWFtTWVzc2FnZRIgCgdlbnRyaWVzGAEgAygLMg8udjEuU3RyZWFtRW50cnkSDgoGaGFuZ3VwGAIgASgIEg4KBmN1cnNvchgDIAEoCSJzCgtTdHJlYW1FbnRyeRIPCgdwYXlsb2FkGAEgASgMEg4KBmN1cnNvchgCIAEoCRIuCgpjcmVhdGVkX2F0GAMgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBITCgtwYXlsb2FkX3JlZhgEIAEoCSJBCh1HZXRTdHJlYW1Ub3BpY01ldGFkYXRhUmVxdWVzdBIRCgluYW1lc3BhY2UYASABKAkSDQoFdG9waWMYAiABKAkixgEKE1N0cmVhbVRvcGljTWV0YWRhdGESEQoJbmFtZXNwYWNlGAEgASgJEg0KBXRvcGljGAIgASgJEhEKCXRlbmFudF9pZBgDIAEoCRIaCg1sYXRlc3RfY3Vyc29yGAQgASgJSACIAQESFQoNbWVzc2FnZV9jb3VudBgFIAEoAxI1ChFsYXN0X3B1Ymxpc2hlZF9hdBgGIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCEAoOX2xhdGVzdF9jdXJzb3Iy7QEKCVYxU3RyZWFtcxJOCgdQdWJsaXNoEh8udjEuUHVibGlzaFN0cmVhbU1lc3NhZ2VSZXF1ZXN0GiAudjEuUHVibGlzaFN0cmVhbU1lc3NhZ2VSZXNwb25zZSIAEj4KCVN1YnNjcmliZRIaLnYxLlN1YnNjcmliZVN0cmVhbVJlcXVlc3QaES52MS5TdHJlYW1NZXNzYWdlIgAwARJQChBHZXRUb3BpY01ldGFkYXRhEiEudjEuR2V0U3RyZWFtVG9waWNNZXRhZGF0YVJlcXVlc3QaFy52MS5TdHJlYW1Ub3BpY01ldGFkYXRhIgBCQlpAZ2l0aHViLmNvbS9oYXRjaGV0LWRldi9oYXRjaGV0L2ludGVybmFsL3NlcnZpY2VzL3NoYXJlZC9wcm90by92MWIGcHJvdG8z", [wkt_1.file_google_protobuf_timestamp]);
+exports.file_v1_streams = (0, codegenv2_1.fileDesc)("ChB2MS9zdHJlYW1zLnByb3RvEgJ2MSKQAQobUHVibGlzaFN0cmVhbU1lc3NhZ2VSZXF1ZXN0EhEKCW5hbWVzcGFjZRgBIAEoCRINCgV0b3BpYxgCIAEoCRIPCgdwYXlsb2FkGAMgASgMEhMKC3Byb2R1Y2VyX2lkGAQgASgJEhQKDHByb2R1Y2VyX3NlcRgFIAEoAxITCgtwYXlsb2FkX3JlZhgGIAEoCSIeChxQdWJsaXNoU3RyZWFtTWVzc2FnZVJlc3BvbnNlIloKFlN1YnNjcmliZVN0cmVhbVJlcXVlc3QSEQoJbmFtZXNwYWNlGAEgASgJEg0KBXRvcGljGAIgASgJEhMKBmN1cnNvchgDIAEoCUgAiAEBQgkKB19jdXJzb3IiUQoNU3RyZWFtTWVzc2FnZRIgCgdlbnRyaWVzGAEgAygLMg8udjEuU3RyZWFtRW50cnkSDgoGaGFuZ3VwGAIgASgIEg4KBmN1cnNvchgDIAEoCSJzCgtTdHJlYW1FbnRyeRIPCgdwYXlsb2FkGAEgASgMEg4KBmN1cnNvchgCIAEoCRIuCgpjcmVhdGVkX2F0GAMgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBITCgtwYXlsb2FkX3JlZhgEIAEoCSJBCh1HZXRTdHJlYW1Ub3BpY01ldGFkYXRhUmVxdWVzdBIRCgluYW1lc3BhY2UYASABKAkSDQoFdG9waWMYAiABKAkixgEKE1N0cmVhbVRvcGljTWV0YWRhdGESEQoJbmFtZXNwYWNlGAEgASgJEg0KBXRvcGljGAIgASgJEhEKCXRlbmFudF9pZBgDIAEoCRIaCg1sYXRlc3RfY3Vyc29yGAQgASgJSACIAQESFQoNbWVzc2FnZV9jb3VudBgFIAEoAxI1ChFsYXN0X3B1Ymxpc2hlZF9hdBgGIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCEAoOX2xhdGVzdF9jdXJzb3IiOwoXUmVzZXRTdHJlYW1Ub3BpY1JlcXVlc3QSEQoJbmFtZXNwYWNlGAEgASgJEg0KBXRvcGljGAIgASgJIhoKGFJlc2V0U3RyZWFtVG9waWNSZXNwb25zZTKzAgoJVjFTdHJlYW1zEk4KB1B1Ymxpc2gSHy52MS5QdWJsaXNoU3RyZWFtTWVzc2FnZVJlcXVlc3QaIC52MS5QdWJsaXNoU3RyZWFtTWVzc2FnZVJlc3BvbnNlIgASPgoJU3Vic2NyaWJlEhoudjEuU3Vic2NyaWJlU3RyZWFtUmVxdWVzdBoRLnYxLlN0cmVhbU1lc3NhZ2UiADABElAKEEdldFRvcGljTWV0YWRhdGESIS52MS5HZXRTdHJlYW1Ub3BpY01ldGFkYXRhUmVxdWVzdBoXLnYxLlN0cmVhbVRvcGljTWV0YWRhdGEiABJECgVSZXNldBIbLnYxLlJlc2V0U3RyZWFtVG9waWNSZXF1ZXN0GhwudjEuUmVzZXRTdHJlYW1Ub3BpY1Jlc3BvbnNlIgBCQlpAZ2l0aHViLmNvbS9oYXRjaGV0LWRldi9oYXRjaGV0L2ludGVybmFsL3NlcnZpY2VzL3NoYXJlZC9wcm90by92MWIGcHJvdG8z", [wkt_1.file_google_protobuf_timestamp]);
 /**
  * Describes the message v1.PublishStreamMessageRequest.
  * Use `create(PublishStreamMessageRequestSchema)` to create a new message.
@@ -45,6 +45,16 @@ exports.GetStreamTopicMetadataRequestSchema = (0, codegenv2_1.messageDesc)(expor
  * Use `create(StreamTopicMetadataSchema)` to create a new message.
  */
 exports.StreamTopicMetadataSchema = (0, codegenv2_1.messageDesc)(exports.file_v1_streams, 6);
+/**
+ * Describes the message v1.ResetStreamTopicRequest.
+ * Use `create(ResetStreamTopicRequestSchema)` to create a new message.
+ */
+exports.ResetStreamTopicRequestSchema = (0, codegenv2_1.messageDesc)(exports.file_v1_streams, 7);
+/**
+ * Describes the message v1.ResetStreamTopicResponse.
+ * Use `create(ResetStreamTopicResponseSchema)` to create a new message.
+ */
+exports.ResetStreamTopicResponseSchema = (0, codegenv2_1.messageDesc)(exports.file_v1_streams, 8);
 /**
  * @generated from service v1.V1Streams
  */