@slatedb/uniffi 0.12.0

package/runtime/rust-call.d.ts

@@ -0,0 +1,77 @@
+import type { RustBufferStruct, RustCallStatusStruct } from "./ffi-types.js";
+
+export declare const CALL_SUCCESS: 0;
+export declare const CALL_ERROR: 1;
+export declare const CALL_UNEXPECTED_ERROR: 2;
+export declare const CALL_CANCELLED: 3;
+
+export type RustStringLifter = (bytes: Uint8Array) => string;
+export type RustErrorHandler<E extends Error = Error> = (
+  bytes: Uint8Array,
+  status: RustCallStatusStruct,
+) => E;
+export type RustCallStatusReader<Status = RustCallStatusStruct> = (
+  status: Status,
+) => RustCallStatusStruct | null | undefined;
+export type RustCallStatusWriter<Status = RustCallStatusStruct> = (
+  status: Status,
+  value: RustCallStatusStruct,
+) => Status;
+
+export interface RustCallOptions<E extends Error = Error> {
+  errorHandler?: RustErrorHandler<E>;
+  freeRustBuffer?: ((buffer: RustBufferStruct) => void) | null;
+  liftString?: RustStringLifter;
+}
+
+export declare function createRustCallStatus(
+  code?: number,
+  error_buf?: RustBufferStruct | null,
+): RustCallStatusStruct;
+export declare function createRustErrorStatus(
+  code?: number,
+  error_buf?: RustBufferStruct | null,
+): RustCallStatusStruct;
+export declare function checkRustCallStatus<E extends Error = Error>(
+  status: RustCallStatusStruct | null | undefined,
+  options?: RustCallOptions<E>,
+): RustCallStatusStruct;
+export declare function rustCall<T, E extends Error = Error>(
+  caller: (status: RustCallStatusStruct) => T,
+  options?: RustCallOptions<E>,
+): T;
+export declare function rustCallWithError<T, E extends Error = Error>(
+  errorHandler: RustErrorHandler<E>,
+  caller: (status: RustCallStatusStruct) => T,
+  options?: Omit<RustCallOptions<E>, "errorHandler">,
+): T;
+
+export declare class UniffiRustCaller<
+  Status = RustCallStatusStruct,
+> {
+  constructor(options?: {
+    createStatus?: () => Status;
+    disposeStatus?: ((status: Status) => void) | null;
+    freeRustBuffer?: ((buffer: RustBufferStruct) => void) | null;
+    liftString?: RustStringLifter;
+    readStatus?: RustCallStatusReader<Status>;
+    writeStatus?: RustCallStatusWriter<Status>;
+  });
+  createCallStatus(): Status;
+  createErrorStatus(code?: number, error_buf?: RustBufferStruct | null): Status;
+  makeRustCall<T, E extends Error = Error>(
+    caller: (status: Status) => T,
+    options?: RustCallOptions<E>,
+  ): T;
+  rustCall<T, E extends Error = Error>(
+    caller: (status: Status) => T,
+    options?: RustCallOptions<E>,
+  ): T;
+  rustCallWithError<T, E extends Error = Error>(
+    errorHandler: RustErrorHandler<E>,
+    caller: (status: Status) => T,
+    options?: Omit<RustCallOptions<E>, "errorHandler">,
+  ): T;
+}
+
+export declare const defaultRustCaller: UniffiRustCaller;

package/runtime/rust-call.js

@@ -0,0 +1,233 @@
+import {
+  AbortError,
+  RustPanic,
+  UnexpectedRustCallError,
+  UnexpectedRustCallStatusCode,
+} from "./errors.js";
+import { FfiConverterString } from "./ffi-converters.js";
+import {
+  EMPTY_RUST_BUFFER,
+  EMPTY_RUST_CALL_STATUS,
+  RustBufferValue,
+  RustCallStatusCodes,
+  normalizeRustBuffer,
+  normalizeRustCallStatus,
+} from "./ffi-types.js";
+
+export const CALL_SUCCESS = RustCallStatusCodes.SUCCESS;
+export const CALL_ERROR = RustCallStatusCodes.ERROR;
+export const CALL_UNEXPECTED_ERROR = RustCallStatusCodes.UNEXPECTED_ERROR;
+export const CALL_CANCELLED = RustCallStatusCodes.CANCELLED;
+
+function defaultLiftString(bytes) {
+  return FfiConverterString.lift(bytes);
+}
+
+function defaultReadStatus(status) {
+  return status;
+}
+
+function defaultWriteStatus(status, value) {
+  if (status == null || typeof status !== "object") {
+    return value;
+  }
+
+  status.code = value.code;
+  status.error_buf = createMutableRustBuffer(value.error_buf);
+  return status;
+}
+
+function createMutableRustBuffer(buffer = EMPTY_RUST_BUFFER) {
+  return normalizeRustBuffer(buffer) ?? {
+    capacity: 0n,
+    len: 0n,
+    data: null,
+  };
+}
+
+function isEmptyRustBuffer(buffer) {
+  return (
+    buffer == null
+    || (
+      buffer.data == null
+      && buffer.len === 0n
+      && buffer.capacity === 0n
+    )
+  );
+}
+
+function consumeRustBuffer(buffer, freeRustBuffer) {
+  const normalized = createMutableRustBuffer(buffer);
+  if (normalized.len === 0n) {
+    return new Uint8Array();
+  }
+
+  const rustBuffer = new RustBufferValue(normalized);
+  if (typeof freeRustBuffer === "function") {
+    return rustBuffer.consumeIntoUint8Array(freeRustBuffer);
+  }
+  return rustBuffer.toUint8Array();
+}
+
+export function createRustCallStatus(
+  code = CALL_SUCCESS,
+  error_buf = EMPTY_RUST_BUFFER,
+) {
+  return {
+    code,
+    error_buf: createMutableRustBuffer(error_buf),
+  };
+}
+
+export function createRustErrorStatus(
+  code = CALL_ERROR,
+  error_buf = EMPTY_RUST_BUFFER,
+) {
+  return createRustCallStatus(code, error_buf);
+}
+
+function checkRustCallStatusImpl(
+  status,
+  options,
+  freeRustBuffer,
+  liftString,
+  errorHandlerOverride = undefined,
+) {
+  if (status?.code === CALL_SUCCESS && isEmptyRustBuffer(status.error_buf)) {
+    return status;
+  }
+
+  const normalized = normalizeRustCallStatus(status) ?? createRustCallStatus();
+  const errorHandler = errorHandlerOverride ?? options?.errorHandler;
+  const resolvedFreeRustBuffer = options?.freeRustBuffer ?? freeRustBuffer;
+  const resolvedLiftString = options?.liftString ?? liftString;
+
+  switch (normalized.code) {
+    case CALL_SUCCESS:
+      return normalized;
+
+    case CALL_ERROR: {
+      const errorBytes = consumeRustBuffer(normalized.error_buf, resolvedFreeRustBuffer);
+      if (typeof errorHandler === "function") {
+        throw errorHandler(errorBytes, normalized);
+      }
+      throw new UnexpectedRustCallError();
+    }
+
+    case CALL_UNEXPECTED_ERROR: {
+      const errorBytes = consumeRustBuffer(normalized.error_buf, resolvedFreeRustBuffer);
+      const message =
+        errorBytes.byteLength === 0
+          ? "Rust panic"
+          : resolvedLiftString(errorBytes);
+      throw new RustPanic(message, { captureStack: false });
+    }
+
+    case CALL_CANCELLED:
+      throw new AbortError();
+
+    default:
+      throw new UnexpectedRustCallStatusCode(normalized.code);
+  }
+}
+
+export function checkRustCallStatus(status, options = undefined) {
+  return checkRustCallStatusImpl(
+    status,
+    options,
+    undefined,
+    defaultLiftString,
+  );
+}
+
+export function rustCall(caller, options = undefined) {
+  const status = createRustCallStatus();
+  const result = caller(status);
+  checkRustCallStatusImpl(status, options, undefined, defaultLiftString);
+  return result;
+}
+
+export function rustCallWithError(errorHandler, caller, options = undefined) {
+  const status = createRustCallStatus();
+  const result = caller(status);
+  checkRustCallStatusImpl(
+    status,
+    options,
+    undefined,
+    defaultLiftString,
+    errorHandler,
+  );
+  return result;
+}
+
+export class UniffiRustCaller {
+  constructor({
+    createStatus = () => createRustCallStatus(),
+    disposeStatus = undefined,
+    freeRustBuffer = undefined,
+    liftString = defaultLiftString,
+    readStatus = defaultReadStatus,
+    writeStatus = defaultWriteStatus,
+  } = {}) {
+    this._createStatus = createStatus;
+    this._disposeStatus = disposeStatus;
+    this._freeRustBuffer = freeRustBuffer;
+    this._liftString = liftString;
+    this._readStatus = readStatus;
+    this._writeStatus = writeStatus;
+  }
+
+  createCallStatus() {
+    return this._writeStatus(this._createStatus(), EMPTY_RUST_CALL_STATUS);
+  }
+
+  createErrorStatus(code = CALL_ERROR, error_buf = EMPTY_RUST_BUFFER) {
+    return this._writeStatus(
+      this._createStatus(),
+      createRustCallStatus(code, error_buf),
+    );
+  }
+
+  makeRustCall(caller, options = undefined) {
+    const status = this.createCallStatus();
+    try {
+      const result = caller(status);
+      checkRustCallStatusImpl(
+        this._readStatus(status),
+        options,
+        this._freeRustBuffer,
+        this._liftString,
+      );
+      return result;
+    } finally {
+      if (typeof this._disposeStatus === "function") {
+        this._disposeStatus(status);
+      }
+    }
+  }
+
+  rustCall(caller, options = undefined) {
+    return this.makeRustCall(caller, options);
+  }
+
+  rustCallWithError(errorHandler, caller, options = undefined) {
+    const status = this.createCallStatus();
+    try {
+      const result = caller(status);
+      checkRustCallStatusImpl(
+        this._readStatus(status),
+        options,
+        this._freeRustBuffer,
+        this._liftString,
+        errorHandler,
+      );
+      return result;
+    } finally {
+      if (typeof this._disposeStatus === "function") {
+        this._disposeStatus(status);
+      }
+    }
+  }
+}
+
+export const defaultRustCaller = new UniffiRustCaller();