@restatedev/restate-sdk-core 1.16.8 → 1.17.0

package/dist/interface.js

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2023-2026 - Restate Software, Inc., Restate GmbH
+ *
+ * This file is part of the Restate SDK for Node.js/TypeScript,
+ * which is released under the MIT license.
+ *
+ * You can find a copy of the license in file LICENSE in the root
+ * directory of this repository or package, or at
+ * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { serde } from "./serde_api.js";
+export function makeHandlerDescriptor(inputSerde, outputSerde, shared) {
+    return {
+        _inputSerde: inputSerde,
+        _outputSerde: outputSerde,
+        _shared: shared,
+    };
+}
+/**
+ * Declare a service interface (contract) as a runtime value carrying handler
+ * names + input/output serdes, without an implementation. Place it in a shared
+ * package that both the server (via `implement()`) and callers (via
+ * `ctx.serviceClient(iface)` / `connect().serviceClient(iface)`) import.
+ *
+ * @example
+ * ```ts
+ * const greeter = iface.service("greeter", {
+ *   greet: iface.schemas({ input: GreetReq, output: GreetRes }),
+ *   ping:  iface.json<void, string>(),
+ * });
+ * ```
+ */
+export const iface = {
+    service: function (name, handlers) {
+        return { name, _kind: "service", _handlers: handlers };
+    },
+    object: function (name, handlers) {
+        return { name, _kind: "object", _handlers: handlers };
+    },
+    workflow: function (name, handlers) {
+        return { name, _kind: "workflow", _handlers: handlers };
+    },
+    json: function () {
+        return makeHandlerDescriptor(undefined, undefined, false);
+    },
+    serdes: function (opts) {
+        return makeHandlerDescriptor(opts.input, opts.output, false);
+    },
+    schemas: function (opts) {
+        return makeHandlerDescriptor(opts.input ? serde.schema(opts.input) : undefined, opts.output ? serde.schema(opts.output) : undefined, false);
+    },
+    shared: {
+        json: function () {
+            return makeHandlerDescriptor(undefined, undefined, true);
+        },
+        serdes: function (opts) {
+            return makeHandlerDescriptor(opts.input, opts.output, true);
+        },
+        schemas: function (opts) {
+            return makeHandlerDescriptor(opts.input ? serde.schema(opts.input) : undefined, opts.output ? serde.schema(opts.output) : undefined, true);
+        },
+    },
+};
+//# sourceMappingURL=interface.js.map

package/dist/interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.js","sourceRoot":"","sources":["../src/interface.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,uDAAuD;AAGvD,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAsBvC,MAAM,UAAU,qBAAqB,CACnC,UAAqB,EACrB,WAAsB,EACtB,MAAe;IAEf,OAAO;QACL,WAAW,EAAE,UAAU;QACvB,YAAY,EAAE,WAAW;QACzB,OAAO,EAAE,MAAM;KAChB,CAAC;AACJ,CAAC;AA4ID;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,KAAK,GAAqB;IACrC,OAAO,EAAE,UAGP,IAAO,EAAE,QAAW;QACpB,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC;IACzD,CAAC;IACD,MAAM,EAAE,UAGN,IAAO,EAAE,QAAW;QACpB,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC;IACxD,CAAC;IACD,QAAQ,EAAE,UAGR,IAAO,EAAE,QAAW;QACpB,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC;IAC1D,CAAC;IACD,IAAI,EAAE;QACJ,OAAO,qBAAqB,CAAc,SAAS,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;IACzE,CAAC;IACD,MAAM,EAAE,UAAwD,IAG/D;QACC,OAAO,qBAAqB,CAC1B,IAAI,CAAC,KAAK,EACV,IAAI,CAAC,MAAM,EACX,KAAK,CACN,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,UAGP,IAGD;QAKC,OAAO,qBAAqB,CAC1B,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,EACjD,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,EACnD,KAAK,CACN,CAAC;IACJ,CAAC;IACD,MAAM,EAAE;QACN,IAAI,EAAE;YACJ,OAAO,qBAAqB,CAAa,SAAS,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;QACvE,CAAC;QACD,MAAM,EAAE,UAAwD,IAG/D;YACC,OAAO,qBAAqB,CAC1B,IAAI,CAAC,KAAK,EACV,IAAI,CAAC,MAAM,EACX,IAAI,CACL,CAAC;QACJ,CAAC;QACD,OAAO,EAAE,UAGP,IAGD;YAKC,OAAO,qBAAqB,CAC1B,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,EACjD,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,EACnD,IAAI,CACL,CAAC;QACJ,CAAC;KACF;CACF,CAAC"}

package/dist/serde_api.d.ts

@@ -1,7 +1,4 @@
-import { StandardSchemaV1 } from "./standard_schema.js";
-
-//#region src/serde_api.d.ts
-
+import type { StandardSchemaV1 } from "./standard_schema.js";
 /**
  * Serializer/deserializer pair for any Restate-managed value of type `T` —
  * handler inputs and outputs, service state, side-effect results,
@@ -19,117 +16,115 @@ import { StandardSchemaV1 } from "./standard_schema.js";
  * It also advertises metadata (`contentType`, `jsonSchema`) that surfaces in
  * service discovery.
  */
-interface Serde<T> {
-  /**
-   * MIME type of the bytes produced by `serialize` (and accepted by
-   * `deserialize`).
-   */
-  contentType?: string;
-  /**
-   * Optional JSON Schema describing the logical shape of `T`. Surfaced in
-   * discovery so that tooling can generate forms, auto-complete payloads,
-   * etc. Has no effect on serialization at runtime.
-   */
-  jsonSchema?: object;
-  /**
-   * Optional bridge between the serde's wire format and a JSON
-   * representation that humans (and tooling like the Restate UI) can read
-   * and edit.
-   *
-   * Only useful for serdes whose wire format isn't already plain JSON —
-   * protobuf, MessagePack, length-prefixed binary, JSON variants that need
-   * post-processing for bigints/dates, etc. Both methods may be async if the
-   * conversion needs I/O.
-   *
-   * ### Preview flow
-   *
-   * Together with `serialize` / `deserialize`, the four functions chain in
-   * both directions between a JSON string and on-the-wire bytes:
-   *
-   * ```text
-   * JSON string  ──fromJsonString──►  T  ──serialize──►  wire bytes
-   * wire bytes   ──deserialize────►  T  ──toJsonString──►  JSON string
-   * ```
-   *
-   * The split keeps `serialize` / `deserialize` responsible for the full
-   * on-the-wire format; `preview` only handles the JSON ↔ `T` bridge.
-   *
-   * @example
-   * ```ts
-   * // Wire format is protobuf; the protobuf-es runtime already ships
-   * // `toJsonString` / `fromJsonString`, so preview is a direct pass-through.
-   * import {
-   *   fromBinary,
-   *   fromJsonString,
-   *   toBinary,
-   *   toJsonString,
-   * } from "@bufbuild/protobuf";
-   * import { PersonSchema, type Person } from "./person_pb.js";
-   *
-   * const personSerde: Serde<Person> = {
-   *   contentType: "application/protobuf",
-   *   serialize(message) { return toBinary(PersonSchema, message); },
-   *   deserialize(bytes) { return fromBinary(PersonSchema, bytes); },
-   *   preview: {
-   *     toJsonString: (v) => toJsonString(PersonSchema, v),
-   *     fromJsonString: (j) => fromJsonString(PersonSchema, j),
-   *   },
-   * };
-   * ```
-   */
-  preview?: {
+export interface Serde<T> {
     /**
-     * Convert a value into a JSON string for display or editing by humans.
-     * The returned string must round-trip through `fromJsonString` back to
-     * the same logical value.
+     * MIME type of the bytes produced by `serialize` (and accepted by
+     * `deserialize`).
      */
-    toJsonString(value: T): Promise<string> | string;
+    contentType?: string;
     /**
-     * Parse a human-supplied JSON string back into a value of type `T`.
-     * Should throw (or reject) if `json` is invalid for this serde.
+     * Optional JSON Schema describing the logical shape of `T`. Surfaced in
+     * discovery so that tooling can generate forms, auto-complete payloads,
+     * etc. Has no effect on serialization at runtime.
+     */
+    jsonSchema?: object;
+    /**
+     * Optional bridge between the serde's wire format and a JSON
+     * representation that humans (and tooling like the Restate UI) can read
+     * and edit.
+     *
+     * Only useful for serdes whose wire format isn't already plain JSON —
+     * protobuf, MessagePack, length-prefixed binary, JSON variants that need
+     * post-processing for bigints/dates, etc. Both methods may be async if the
+     * conversion needs I/O.
+     *
+     * ### Preview flow
+     *
+     * Together with `serialize` / `deserialize`, the four functions chain in
+     * both directions between a JSON string and on-the-wire bytes:
+     *
+     * ```text
+     * JSON string  ──fromJsonString──►  T  ──serialize──►  wire bytes
+     * wire bytes   ──deserialize────►  T  ──toJsonString──►  JSON string
+     * ```
+     *
+     * The split keeps `serialize` / `deserialize` responsible for the full
+     * on-the-wire format; `preview` only handles the JSON ↔ `T` bridge.
+     *
+     * @example
+     * ```ts
+     * // Wire format is protobuf; the protobuf-es runtime already ships
+     * // `toJsonString` / `fromJsonString`, so preview is a direct pass-through.
+     * import {
+     *   fromBinary,
+     *   fromJsonString,
+     *   toBinary,
+     *   toJsonString,
+     * } from "@bufbuild/protobuf";
+     * import { PersonSchema, type Person } from "./person_pb.js";
+     *
+     * const personSerde: Serde<Person> = {
+     *   contentType: "application/protobuf",
+     *   serialize(message) { return toBinary(PersonSchema, message); },
+     *   deserialize(bytes) { return fromBinary(PersonSchema, bytes); },
+     *   preview: {
+     *     toJsonString: (v) => toJsonString(PersonSchema, v),
+     *     fromJsonString: (j) => fromJsonString(PersonSchema, j),
+     *   },
+     * };
+     * ```
+     */
+    preview?: {
+        /**
+         * Convert a value into a JSON string for display or editing by humans.
+         * The returned string must round-trip through `fromJsonString` back to
+         * the same logical value.
+         */
+        toJsonString(value: T): Promise<string> | string;
+        /**
+         * Parse a human-supplied JSON string back into a value of type `T`.
+         * Should throw (or reject) if `json` is invalid for this serde.
+         */
+        fromJsonString(json: string): Promise<T> | T;
+    };
+    /**
+     * Convert a value of type `T` into its on-the-wire bytes. This is the
+     * format Restate sends between services and persists in the journal.
+     *
+     * Must be the inverse of `deserialize` — `deserialize(serialize(v))`
+     * should produce a value equivalent to `v`.
      */
-    fromJsonString(json: string): Promise<T> | T;
-  };
-  /**
-   * Convert a value of type `T` into its on-the-wire bytes. This is the
-   * format Restate sends between services and persists in the journal.
-   *
-   * Must be the inverse of `deserialize` — `deserialize(serialize(v))`
-   * should produce a value equivalent to `v`.
-   */
-  serialize(value: T): Uint8Array;
-  /**
-   * Convert on-the-wire bytes back into a value of type `T`. Must be the
-   * inverse of `serialize`.
-   *
-   * May throw if `data` doesn't conform to the expected wire format.
-   */
-  deserialize(data: Uint8Array): T;
-}
-declare namespace serde {
-  class JsonSerde<T> implements Serde<T | undefined> {
-    readonly jsonSchema?: object | undefined;
-    contentType: string;
-    constructor(jsonSchema?: object | undefined);
     serialize(value: T): Uint8Array;
-    deserialize(data: Uint8Array): T | undefined;
-    schema<U>(schema: object): Serde<U>;
-  }
-  const json: JsonSerde<any>;
-  const binary: Serde<Uint8Array>;
-  const empty: Serde<void>;
-  /**
-   * A Standard Schema-based serde.
-   *
-   * @param schema the standard schema
-   * @param validateOptions options passed to `StandardSchemaV1.Options.libraryOptions` when validating
-   * @param jsonSchemaOptions options passed to `StandardJsonSchemaV1.Options.libraryOptions` for code generation
-   * @returns a serde that will validate the data with the standard schema
-   */
-  const schema: <T extends {
-    "~standard": StandardSchemaV1.Props;
-  }>(schema: T, validateOptions?: Record<string, unknown>, jsonSchemaOptions?: Record<string, unknown>) => Serde<StandardSchemaV1.InferOutput<T>>;
+    /**
+     * Convert on-the-wire bytes back into a value of type `T`. Must be the
+     * inverse of `serialize`.
+     *
+     * May throw if `data` doesn't conform to the expected wire format.
+     */
+    deserialize(data: Uint8Array): T;
+}
+export declare namespace serde {
+    class JsonSerde<T> implements Serde<T | undefined> {
+        readonly jsonSchema?: object | undefined;
+        contentType: string;
+        constructor(jsonSchema?: object | undefined);
+        serialize(value: T): Uint8Array;
+        deserialize(data: Uint8Array): T | undefined;
+        schema<U>(schema: object): Serde<U>;
+    }
+    const json: JsonSerde<any>;
+    const binary: Serde<Uint8Array>;
+    const empty: Serde<void>;
+    /**
+     * A Standard Schema-based serde.
+     *
+     * @param schema the standard schema
+     * @param validateOptions options passed to `StandardSchemaV1.Options.libraryOptions` when validating
+     * @param jsonSchemaOptions options passed to `StandardJsonSchemaV1.Options.libraryOptions` for code generation
+     * @returns a serde that will validate the data with the standard schema
+     */
+    const schema: <T extends {
+        "~standard": StandardSchemaV1.Props;
+    }>(schema: T, validateOptions?: Record<string, unknown>, jsonSchemaOptions?: Record<string, unknown>) => Serde<StandardSchemaV1.InferOutput<T>>;
 }
-//#endregion
-export { Serde, serde };
 //# sourceMappingURL=serde_api.d.ts.map

package/dist/serde_api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serde_api.d.ts","names":[],"sources":["../src/serde_api.ts"],"sourcesContent":[],"mappings":";;;;;;AAoCA;;;;;;;;;;;AAiOA;;;;AAasB,UA9OL,KA8OK,CAAA,CAAA,CAAA,CAAA;EAAa;;;;EAYd,WAAA,CAAA,EAAA,MAAA;EACQ;;;;;EAaP,UAAA,CAAA,EAAA,MAAA;EACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAvMA,IAAI;;;;;kCAMM,QAAQ,KAAK;;;;;;;;;mBAU5B,IAAI;;;;;;;oBAQH,aAAa;;kBAuIhB,KAAA;gCACsB,MAAM;;;;qBAKxB,IAAI;sBAOH,aAAa;+BAOJ,MAAM;;cAKhB;gBACE,MAAM;eACP;;;;;;;;;;iBAU4B,gBAAA,CAAiB;aACvD,qBACU,6CACE,4BACnB,MAAM,gBAAA,CAAiB,YAAY"}
+{"version":3,"file":"serde_api.d.ts","sourceRoot":"","sources":["../src/serde_api.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAEV,gBAAgB,EACjB,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC;IACtB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6CG;IACH,OAAO,CAAC,EAAE;QACR;;;;WAIG;QACH,YAAY,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;QAEjD;;;WAGG;QACH,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;KAC9C,CAAC;IAEF;;;;;;OAMG;IACH,SAAS,CAAC,KAAK,EAAE,CAAC,GAAG,UAAU,CAAC;IAEhC;;;;;OAKG;IACH,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,CAAC,CAAC;CAClC;AAsID,yBAAiB,KAAK,CAAC;IACrB,MAAa,SAAS,CAAC,CAAC,CAAE,YAAW,KAAK,CAAC,CAAC,GAAG,SAAS,CAAC;QAG3C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM;QAFxC,WAAW,SAAsB;oBAEZ,UAAU,CAAC,EAAE,MAAM,YAAA;QAExC,SAAS,CAAC,KAAK,EAAE,CAAC,GAAG,UAAU;QAO/B,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,CAAC,GAAG,SAAS;QAO5C,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC;KAGpC;IAEM,MAAM,IAAI,EAAE,SAAS,CAAC,GAAG,CAAwB,CAAC;IAClD,MAAM,MAAM,EAAE,KAAK,CAAC,UAAU,CAAqB,CAAC;IACpD,MAAM,KAAK,EAAE,KAAK,CAAC,IAAI,CAAmB,CAAC;IAElD;;;;;;;OAOG;IACI,MAAM,MAAM,GAAI,CAAC,SAAS;QAAE,WAAW,EAAE,gBAAgB,CAAC,KAAK,CAAA;KAAE,EACtE,QAAQ,CAAC,EACT,kBAAkB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACzC,oBAAoB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC1C,KAAK,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC,CAAC,CAEvC,CAAC;CACH"}

package/dist/serde_api.js

@@ -1,93 +1,157 @@
-//#region src/serde_api.ts
-var BinarySerde = class {
-	contentType = "application/octet-stream";
-	serialize(value) {
-		return value;
-	}
-	deserialize(data) {
-		return data;
-	}
-};
-var VoidSerde = class {
-	serialize(value) {
-		if (value !== void 0) throw new Error("Expected undefined value");
-		return new Uint8Array(0);
-	}
-	deserialize(data) {
-		if (data.length !== 0) throw new Error("Expected empty data");
-	}
-};
-var StandardSchemaSerde = class {
-	contentType = "application/json";
-	jsonSchema;
-	constructor(schema, validateOptions, jsonSchemaOptions) {
-		this.schema = schema;
-		this.validateOptions = validateOptions;
-		const standard = schema["~standard"];
-		if (isStandardJSONSchemaV1(standard)) try {
-			this.jsonSchema = standard.jsonSchema.output({
-				target: "draft-2020-12",
-				libraryOptions: jsonSchemaOptions
-			});
-		} catch {
-			this.jsonSchema = void 0;
-		}
-		const testResult = standard.validate(void 0);
-		if (testResult && typeof testResult === "object" && "then" in testResult) {} else if (!testResult.issues) this.contentType = void 0;
-	}
-	serialize(value) {
-		if (value === void 0) return new Uint8Array(0);
-		return new TextEncoder().encode(JSON.stringify(value));
-	}
-	deserialize(data) {
-		const js = data.length === 0 ? void 0 : JSON.parse(new TextDecoder().decode(data));
-		const result = this.schema["~standard"].validate(js, this.validateOptions);
-		if (result && typeof result === "object" && "then" in result) throw new TypeError("Async validation is not supported in Serde. Restate SDK supports only synchronous validation.");
-		if (result.issues) {
-			const errorMessages = result.issues.map(formatStandardSchemaIssue).join("\n");
-			throw new TypeError(`Standard schema validation failed:\n${errorMessages}`);
-		}
-		return result.value;
-	}
-};
+/*
+ * Copyright (c) 2023-2024 - Restate Software, Inc., Restate GmbH
+ *
+ * This file is part of the Restate SDK for Node.js/TypeScript,
+ * which is released under the MIT license.
+ *
+ * You can find a copy of the license in file LICENSE in the root
+ * directory of this repository or package, or at
+ * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE
+ */
+class BinarySerde {
+    contentType = "application/octet-stream";
+    serialize(value) {
+        return value;
+    }
+    deserialize(data) {
+        return data;
+    }
+}
+class VoidSerde {
+    serialize(value) {
+        if (value !== undefined) {
+            throw new Error("Expected undefined value");
+        }
+        return new Uint8Array(0);
+    }
+    deserialize(data) {
+        if (data.length !== 0) {
+            throw new Error("Expected empty data");
+        }
+    }
+}
+class StandardSchemaSerde {
+    schema;
+    validateOptions;
+    contentType = "application/json";
+    jsonSchema;
+    constructor(schema, validateOptions, jsonSchemaOptions) {
+        this.schema = schema;
+        this.validateOptions = validateOptions;
+        // Extract JSON schema if available
+        const standard = schema["~standard"];
+        if (isStandardJSONSchemaV1(standard)) {
+            try {
+                this.jsonSchema = standard.jsonSchema.output({
+                    target: "draft-2020-12",
+                    libraryOptions: jsonSchemaOptions,
+                });
+            }
+            catch {
+                // If JSON schema generation fails, leave it undefined
+                this.jsonSchema = undefined;
+            }
+        }
+        // Check if schema is for void/undefined type
+        // Standard Schema doesn't have a direct way to detect void types,
+        // so we serialize undefined and check if validation succeeds
+        const testResult = standard.validate(undefined);
+        // Handle both sync and async validation results
+        if (testResult && typeof testResult === "object" && "then" in testResult) {
+            // If it's a Promise, we can't determine contentType synchronously
+            // Keep contentType as "application/json"
+        }
+        else if (!testResult.issues) {
+            this.contentType = undefined;
+        }
+    }
+    serialize(value) {
+        if (value === undefined) {
+            return new Uint8Array(0);
+        }
+        return new TextEncoder().encode(JSON.stringify(value));
+    }
+    deserialize(data) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const js = data.length === 0
+            ? undefined
+            : JSON.parse(new TextDecoder().decode(data));
+        const result = this.schema["~standard"].validate(js, this.validateOptions);
+        // Standard Schema validate can return a Promise, but Serde must be synchronous
+        if (result && typeof result === "object" && "then" in result) {
+            throw new TypeError("Async validation is not supported in Serde. Restate SDK supports only synchronous validation.");
+        }
+        if (result.issues) {
+            const errorMessages = result.issues
+                .map(formatStandardSchemaIssue)
+                .join("\n");
+            throw new TypeError(`Standard schema validation failed:\n${errorMessages}`);
+        }
+        return result.value;
+    }
+}
 function formatStandardSchemaIssue(issue) {
-	if (issue.path && issue.path.length > 0) return `* (at ${"/" + issue.path.map((p) => {
-		if (typeof p === "object" && p !== null && "key" in p) return String(p.key);
-		return String(p);
-	}).join("/")}) ${issue.message}`;
-	return `* ${issue.message}`;
+    if (issue.path && issue.path.length > 0) {
+        const jsonPointer = "/" +
+            issue.path
+                .map((p) => {
+                // Handle both PathSegment objects and primitive PropertyKey values
+                if (typeof p === "object" && p !== null && "key" in p) {
+                    return String(p.key);
+                }
+                return String(p);
+            })
+                .join("/");
+        return `* (at ${jsonPointer}) ${issue.message}`;
+    }
+    return `* ${issue.message}`;
 }
 function isStandardJSONSchemaV1(standard) {
-	return standard != void 0 && "jsonSchema" in standard && typeof standard.jsonSchema === "object" && standard.jsonSchema !== null && "output" in standard.jsonSchema && typeof standard.jsonSchema.output === "function";
+    return (standard != undefined &&
+        "jsonSchema" in standard &&
+        typeof standard.jsonSchema === "object" &&
+        standard.jsonSchema !== null &&
+        "output" in standard.jsonSchema &&
+        typeof standard.jsonSchema.output === "function");
 }
-let serde;
-(function(_serde) {
-	class JsonSerde {
-		contentType = "application/json";
-		constructor(jsonSchema) {
-			this.jsonSchema = jsonSchema;
-		}
-		serialize(value) {
-			if (value === void 0) return new Uint8Array(0);
-			return new TextEncoder().encode(JSON.stringify(value));
-		}
-		deserialize(data) {
-			if (data.length === 0) return;
-			return JSON.parse(new TextDecoder().decode(data));
-		}
-		schema(schema) {
-			return new JsonSerde(schema);
-		}
-	}
-	_serde.JsonSerde = JsonSerde;
-	_serde.json = new JsonSerde();
-	_serde.binary = new BinarySerde();
-	_serde.empty = new VoidSerde();
-	_serde.schema = (schema, validateOptions, jsonSchemaOptions) => {
-		return new StandardSchemaSerde(schema, validateOptions, jsonSchemaOptions);
-	};
+export var serde;
+(function (serde) {
+    class JsonSerde {
+        jsonSchema;
+        contentType = "application/json";
+        constructor(jsonSchema) {
+            this.jsonSchema = jsonSchema;
+        }
+        serialize(value) {
+            if (value === undefined) {
+                return new Uint8Array(0);
+            }
+            return new TextEncoder().encode(JSON.stringify(value));
+        }
+        deserialize(data) {
+            if (data.length === 0) {
+                return undefined;
+            }
+            return JSON.parse(new TextDecoder().decode(data));
+        }
+        schema(schema) {
+            return new JsonSerde(schema);
+        }
+    }
+    serde.JsonSerde = JsonSerde;
+    serde.json = new JsonSerde();
+    serde.binary = new BinarySerde();
+    serde.empty = new VoidSerde();
+    /**
+     * A Standard Schema-based serde.
+     *
+     * @param schema the standard schema
+     * @param validateOptions options passed to `StandardSchemaV1.Options.libraryOptions` when validating
+     * @param jsonSchemaOptions options passed to `StandardJsonSchemaV1.Options.libraryOptions` for code generation
+     * @returns a serde that will validate the data with the standard schema
+     */
+    serde.schema = (schema, validateOptions, jsonSchemaOptions) => {
+        return new StandardSchemaSerde(schema, validateOptions, jsonSchemaOptions);
+    };
 })(serde || (serde = {}));
-
-//#endregion
-export { serde };
 //# sourceMappingURL=serde_api.js.map

package/dist/serde_api.js.map

@@ -1 +1 @@
-{"version":3,"file":"serde_api.js","names":["schema: T","validateOptions?: Record<string, unknown>","jsonSchema?: object"],"sources":["../src/serde_api.ts"],"sourcesContent":["/*\n * Copyright (c) 2023-2024 - Restate Software, Inc., Restate GmbH\n *\n * This file is part of the Restate SDK for Node.js/TypeScript,\n * which is released under the MIT license.\n *\n * You can find a copy of the license in file LICENSE in the root\n * directory of this repository or package, or at\n * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE\n */\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/no-namespace */\n\nimport type {\n  StandardJSONSchemaV1,\n  StandardSchemaV1,\n} from \"./standard_schema.js\";\n\n/**\n * Serializer/deserializer pair for any Restate-managed value of type `T` —\n * handler inputs and outputs, service state, side-effect results,\n * awakeables, durable promises, and so on.\n *\n * A `Serde<T>` is responsible for two conversions:\n *\n * - **Wire format**: `serialize` / `deserialize` convert a value `T` to and\n *   from the raw bytes that flow over the network and get stored in the\n *   journal.\n * - **JSON preview (optional)**: `preview.toJsonString` /\n *   `preview.fromJsonString` convert a value `T` to and from a JSON string,\n *   used by tooling to render and edit values that humans can read.\n *\n * It also advertises metadata (`contentType`, `jsonSchema`) that surfaces in\n * service discovery.\n */\nexport interface Serde<T> {\n  /**\n   * MIME type of the bytes produced by `serialize` (and accepted by\n   * `deserialize`).\n   */\n  contentType?: string;\n\n  /**\n   * Optional JSON Schema describing the logical shape of `T`. Surfaced in\n   * discovery so that tooling can generate forms, auto-complete payloads,\n   * etc. Has no effect on serialization at runtime.\n   */\n  jsonSchema?: object;\n\n  /**\n   * Optional bridge between the serde's wire format and a JSON\n   * representation that humans (and tooling like the Restate UI) can read\n   * and edit.\n   *\n   * Only useful for serdes whose wire format isn't already plain JSON —\n   * protobuf, MessagePack, length-prefixed binary, JSON variants that need\n   * post-processing for bigints/dates, etc. Both methods may be async if the\n   * conversion needs I/O.\n   *\n   * ### Preview flow\n   *\n   * Together with `serialize` / `deserialize`, the four functions chain in\n   * both directions between a JSON string and on-the-wire bytes:\n   *\n   * ```text\n   * JSON string  ──fromJsonString──►  T  ──serialize──►  wire bytes\n   * wire bytes   ──deserialize────►  T  ──toJsonString──►  JSON string\n   * ```\n   *\n   * The split keeps `serialize` / `deserialize` responsible for the full\n   * on-the-wire format; `preview` only handles the JSON ↔ `T` bridge.\n   *\n   * @example\n   * ```ts\n   * // Wire format is protobuf; the protobuf-es runtime already ships\n   * // `toJsonString` / `fromJsonString`, so preview is a direct pass-through.\n   * import {\n   *   fromBinary,\n   *   fromJsonString,\n   *   toBinary,\n   *   toJsonString,\n   * } from \"@bufbuild/protobuf\";\n   * import { PersonSchema, type Person } from \"./person_pb.js\";\n   *\n   * const personSerde: Serde<Person> = {\n   *   contentType: \"application/protobuf\",\n   *   serialize(message) { return toBinary(PersonSchema, message); },\n   *   deserialize(bytes) { return fromBinary(PersonSchema, bytes); },\n   *   preview: {\n   *     toJsonString: (v) => toJsonString(PersonSchema, v),\n   *     fromJsonString: (j) => fromJsonString(PersonSchema, j),\n   *   },\n   * };\n   * ```\n   */\n  preview?: {\n    /**\n     * Convert a value into a JSON string for display or editing by humans.\n     * The returned string must round-trip through `fromJsonString` back to\n     * the same logical value.\n     */\n    toJsonString(value: T): Promise<string> | string;\n\n    /**\n     * Parse a human-supplied JSON string back into a value of type `T`.\n     * Should throw (or reject) if `json` is invalid for this serde.\n     */\n    fromJsonString(json: string): Promise<T> | T;\n  };\n\n  /**\n   * Convert a value of type `T` into its on-the-wire bytes. This is the\n   * format Restate sends between services and persists in the journal.\n   *\n   * Must be the inverse of `deserialize` — `deserialize(serialize(v))`\n   * should produce a value equivalent to `v`.\n   */\n  serialize(value: T): Uint8Array;\n\n  /**\n   * Convert on-the-wire bytes back into a value of type `T`. Must be the\n   * inverse of `serialize`.\n   *\n   * May throw if `data` doesn't conform to the expected wire format.\n   */\n  deserialize(data: Uint8Array): T;\n}\n\nclass BinarySerde implements Serde<Uint8Array> {\n  contentType = \"application/octet-stream\";\n\n  serialize(value: Uint8Array): Uint8Array {\n    return value;\n  }\n\n  deserialize(data: Uint8Array): Uint8Array {\n    return data;\n  }\n}\n\nclass VoidSerde implements Serde<void> {\n  serialize(value: any): Uint8Array {\n    if (value !== undefined) {\n      throw new Error(\"Expected undefined value\");\n    }\n    return new Uint8Array(0);\n  }\n\n  deserialize(data: Uint8Array): void {\n    if (data.length !== 0) {\n      throw new Error(\"Expected empty data\");\n    }\n  }\n}\n\nclass StandardSchemaSerde<\n  T extends { \"~standard\": StandardSchemaV1.Props },\n> implements Serde<StandardSchemaV1.InferOutput<T>> {\n  contentType? = \"application/json\";\n  jsonSchema?: object | undefined;\n\n  constructor(\n    private readonly schema: T,\n    private readonly validateOptions?: Record<string, unknown>,\n    jsonSchemaOptions?: Record<string, unknown>\n  ) {\n    // Extract JSON schema if available\n    const standard = schema[\"~standard\"];\n    if (isStandardJSONSchemaV1(standard)) {\n      try {\n        this.jsonSchema = (\n          standard as unknown as StandardJSONSchemaV1.Props\n        ).jsonSchema.output({\n          target: \"draft-2020-12\",\n          libraryOptions: jsonSchemaOptions,\n        });\n      } catch {\n        // If JSON schema generation fails, leave it undefined\n        this.jsonSchema = undefined;\n      }\n    }\n\n    // Check if schema is for void/undefined type\n    // Standard Schema doesn't have a direct way to detect void types,\n    // so we serialize undefined and check if validation succeeds\n    const testResult = standard.validate(undefined);\n    // Handle both sync and async validation results\n    if (testResult && typeof testResult === \"object\" && \"then\" in testResult) {\n      // If it's a Promise, we can't determine contentType synchronously\n      // Keep contentType as \"application/json\"\n    } else if (!testResult.issues) {\n      this.contentType = undefined;\n    }\n  }\n\n  serialize(value: StandardSchemaV1.InferOutput<T>): Uint8Array {\n    if (value === undefined) {\n      return new Uint8Array(0);\n    }\n    return new TextEncoder().encode(JSON.stringify(value));\n  }\n\n  deserialize(data: Uint8Array): StandardSchemaV1.InferOutput<T> {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n    const js =\n      data.length === 0\n        ? undefined\n        : JSON.parse(new TextDecoder().decode(data));\n\n    const result = this.schema[\"~standard\"].validate(js, this.validateOptions);\n\n    // Standard Schema validate can return a Promise, but Serde must be synchronous\n    if (result && typeof result === \"object\" && \"then\" in result) {\n      throw new TypeError(\n        \"Async validation is not supported in Serde. Restate SDK supports only synchronous validation.\"\n      );\n    }\n\n    if (result.issues) {\n      const errorMessages = result.issues\n        .map(formatStandardSchemaIssue)\n        .join(\"\\n\");\n      throw new TypeError(\n        `Standard schema validation failed:\\n${errorMessages}`\n      );\n    }\n\n    return result.value as StandardSchemaV1.InferOutput<T>;\n  }\n}\n\nfunction formatStandardSchemaIssue(issue: StandardSchemaV1.Issue): string {\n  if (issue.path && issue.path.length > 0) {\n    const jsonPointer =\n      \"/\" +\n      issue.path\n        .map((p) => {\n          // Handle both PathSegment objects and primitive PropertyKey values\n          if (typeof p === \"object\" && p !== null && \"key\" in p) {\n            return String(p.key);\n          }\n          return String(p);\n        })\n        .join(\"/\");\n    return `* (at ${jsonPointer}) ${issue.message}`;\n  }\n  return `* ${issue.message}`;\n}\n\nfunction isStandardJSONSchemaV1(standard: StandardSchemaV1.Props): boolean {\n  return (\n    standard != undefined &&\n    \"jsonSchema\" in standard &&\n    typeof standard.jsonSchema === \"object\" &&\n    standard.jsonSchema !== null &&\n    \"output\" in standard.jsonSchema &&\n    typeof standard.jsonSchema.output === \"function\"\n  );\n}\n\nexport namespace serde {\n  export class JsonSerde<T> implements Serde<T | undefined> {\n    contentType = \"application/json\";\n\n    constructor(readonly jsonSchema?: object) {}\n\n    serialize(value: T): Uint8Array {\n      if (value === undefined) {\n        return new Uint8Array(0);\n      }\n      return new TextEncoder().encode(JSON.stringify(value));\n    }\n\n    deserialize(data: Uint8Array): T | undefined {\n      if (data.length === 0) {\n        return undefined;\n      }\n      return JSON.parse(new TextDecoder().decode(data)) as T;\n    }\n\n    schema<U>(schema: object): Serde<U> {\n      return new JsonSerde<U>(schema) as Serde<U>;\n    }\n  }\n\n  export const json: JsonSerde<any> = new JsonSerde<any>();\n  export const binary: Serde<Uint8Array> = new BinarySerde();\n  export const empty: Serde<void> = new VoidSerde();\n\n  /**\n   * A Standard Schema-based serde.\n   *\n   * @param schema the standard schema\n   * @param validateOptions options passed to `StandardSchemaV1.Options.libraryOptions` when validating\n   * @param jsonSchemaOptions options passed to `StandardJsonSchemaV1.Options.libraryOptions` for code generation\n   * @returns a serde that will validate the data with the standard schema\n   */\n  export const schema = <T extends { \"~standard\": StandardSchemaV1.Props }>(\n    schema: T,\n    validateOptions?: Record<string, unknown>,\n    jsonSchemaOptions?: Record<string, unknown>\n  ): Serde<StandardSchemaV1.InferOutput<T>> => {\n    return new StandardSchemaSerde(schema, validateOptions, jsonSchemaOptions);\n  };\n}\n"],"mappings":";AAiIA,IAAM,cAAN,MAA+C;CAC7C,cAAc;CAEd,UAAU,OAA+B;AACvC,SAAO;;CAGT,YAAY,MAA8B;AACxC,SAAO;;;AAIX,IAAM,YAAN,MAAuC;CACrC,UAAU,OAAwB;AAChC,MAAI,UAAU,OACZ,OAAM,IAAI,MAAM,2BAA2B;AAE7C,SAAO,IAAI,WAAW,EAAE;;CAG1B,YAAY,MAAwB;AAClC,MAAI,KAAK,WAAW,EAClB,OAAM,IAAI,MAAM,sBAAsB;;;AAK5C,IAAM,sBAAN,MAEoD;CAClD,cAAe;CACf;CAEA,YACE,AAAiBA,QACjB,AAAiBC,iBACjB,mBACA;EAHiB;EACA;EAIjB,MAAM,WAAW,OAAO;AACxB,MAAI,uBAAuB,SAAS,CAClC,KAAI;AACF,QAAK,aACH,SACA,WAAW,OAAO;IAClB,QAAQ;IACR,gBAAgB;IACjB,CAAC;UACI;AAEN,QAAK,aAAa;;EAOtB,MAAM,aAAa,SAAS,SAAS,OAAU;AAE/C,MAAI,cAAc,OAAO,eAAe,YAAY,UAAU,YAAY,YAG/D,CAAC,WAAW,OACrB,MAAK,cAAc;;CAIvB,UAAU,OAAoD;AAC5D,MAAI,UAAU,OACZ,QAAO,IAAI,WAAW,EAAE;AAE1B,SAAO,IAAI,aAAa,CAAC,OAAO,KAAK,UAAU,MAAM,CAAC;;CAGxD,YAAY,MAAmD;EAE7D,MAAM,KACJ,KAAK,WAAW,IACZ,SACA,KAAK,MAAM,IAAI,aAAa,CAAC,OAAO,KAAK,CAAC;EAEhD,MAAM,SAAS,KAAK,OAAO,aAAa,SAAS,IAAI,KAAK,gBAAgB;AAG1E,MAAI,UAAU,OAAO,WAAW,YAAY,UAAU,OACpD,OAAM,IAAI,UACR,gGACD;AAGH,MAAI,OAAO,QAAQ;GACjB,MAAM,gBAAgB,OAAO,OAC1B,IAAI,0BAA0B,CAC9B,KAAK,KAAK;AACb,SAAM,IAAI,UACR,uCAAuC,gBACxC;;AAGH,SAAO,OAAO;;;AAIlB,SAAS,0BAA0B,OAAuC;AACxE,KAAI,MAAM,QAAQ,MAAM,KAAK,SAAS,EAYpC,QAAO,SAVL,MACA,MAAM,KACH,KAAK,MAAM;AAEV,MAAI,OAAO,MAAM,YAAY,MAAM,QAAQ,SAAS,EAClD,QAAO,OAAO,EAAE,IAAI;AAEtB,SAAO,OAAO,EAAE;GAChB,CACD,KAAK,IAAI,CACc,IAAI,MAAM;AAExC,QAAO,KAAK,MAAM;;AAGpB,SAAS,uBAAuB,UAA2C;AACzE,QACE,YAAY,UACZ,gBAAgB,YAChB,OAAO,SAAS,eAAe,YAC/B,SAAS,eAAe,QACxB,YAAY,SAAS,cACrB,OAAO,SAAS,WAAW,WAAW;;;;CAKjC,MAAM,UAA6C;EACxD,cAAc;EAEd,YAAY,AAASC,YAAqB;GAArB;;EAErB,UAAU,OAAsB;AAC9B,OAAI,UAAU,OACZ,QAAO,IAAI,WAAW,EAAE;AAE1B,UAAO,IAAI,aAAa,CAAC,OAAO,KAAK,UAAU,MAAM,CAAC;;EAGxD,YAAY,MAAiC;AAC3C,OAAI,KAAK,WAAW,EAClB;AAEF,UAAO,KAAK,MAAM,IAAI,aAAa,CAAC,OAAO,KAAK,CAAC;;EAGnD,OAAU,QAA0B;AAClC,UAAO,IAAI,UAAa,OAAO;;;;eAIC,IAAI,WAAgB;iBACf,IAAI,aAAa;gBACxB,IAAI,WAAW;kBAW/C,QACA,iBACA,sBAC2C;AAC3C,SAAO,IAAI,oBAAoB,QAAQ,iBAAiB,kBAAkB"}
+{"version":3,"file":"serde_api.js","sourceRoot":"","sources":["../src/serde_api.ts"],"names":[],"mappings":"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"}