Additional Runtime APIs

import { generateIdempotencyKey, Uuid } from "golem:api/host@1.1.7";
 
const key: Uuid = generateIdempotencyKey();

export type WorkerMetadata = {
    workerId: WorkerId;
    args: string[];
    env: [string, string][];
    wasiConfigVars: [string, string][];
    status: WorkerStatus;
    componentVersion: bigint;
    retryCount: bigint;
};

import {
  ComponentId,
  GetWorkers,
  WorkerAnyFilter,
  WorkerMetadata,
  WorkerStatusFilter,
} from "golem:api/host@1.1.0"
 
const filter: WorkerAnyFilter = {
  filters: [
    {
      filters: [
        {
          tag: "status",
          val: {
            comparator: "equal",
            value: "idle",
          } satisfies WorkerStatusFilter,
        },
      ],
    },
  ],
}
 
const componentId: ComponentId = {
  /* ... */
}
const workers: WorkerMetadata[] = []
const getter = new GetWorkers(componentId, filter, true)
 
let batch: WorkerMetadata[] | undefined
while ((batch = getter.getNext()) !== undefined) {
  workers.push(...batch)
}

import { updateWorker, WorkerId, ComponentVersion } from "golem:api/host@0.2.0"
 
const workerId: WorkerId = {
  /* ... */
}
 
const targetVersion: ComponentVersion = 1n
 
updateWorker(workerId, targetVersion, "automatic")

export type DurableFunctionType =
  {
    tag: 'read-local'
  } |
  {
    tag: 'write-local'
  } |
  {
    tag: 'read-remote'
  } |
  {
    tag: 'write-remote'
  } |
  {
    tag: 'write-remote-batched'
    val: OplogIndex | undefined
  } |
  {
    tag: 'write-remote-transaction'
    val: OplogIndex | undefined
  };

/**
 * Gets the current durable execution state
 */
export function currentDurableExecutionState(): DurableExecutionState;
 
export type DurableExecutionState = {
  isLive: boolean;
  persistenceLevel: PersistenceLevel;
};
 
/**
 * Configurable persistence level for workers
 */
export type PersistenceLevel = {
    tag: 'persist-nothing'
  } |
  {
    tag: 'persist-remote-side-effects'
  } |
  {
    tag: 'smart'
  };

export type PersistedTypedDurableFunctionInvocation = {
  timestamp: Datetime;
  functionName: string;
  response: ValueAndType;
  functionType: DurableFunctionType;
  entryVersion: OplogEntryVersion;
};

/**
 * Invocation context support
 */
declare module 'golem:api/context@1.1.7' {
  /**
   * Gets the current invocation context
   * The function call captures the current context; if new spans are started, the returned `invocation-context` instance will not
   * reflect that.
   */
  export function currentContext(): InvocationContext;
}

/**
 * Starts a new `span` with the given name, as a child of the current invocation context
 */
export function startSpan(name: string): Span;

/**
* Get the value associated with the key in the bucket.
* The value is returned as an option. If the key-value pair exists in the
* bucket, it returns `Ok(value)`. If the key does not exist in the
* bucket, it returns `Ok(none)`.
* If any other error occurs, it returns an `Err(error)`.
* @throws Error
*/
export function get(bucket: Bucket, key: Key): IncomingValue | undefined;
/**
* Set the value associated with the key in the bucket. If the key already
* exists in the bucket, it overwrites the value.
* If the key does not exist in the bucket, it creates a new key-value pair.
* If any other error occurs, it returns an `Err(error)`.
* @throws Error
*/
export function set(bucket: Bucket, key: Key, outgoingValue: OutgoingValue): void;
/**
* Delete the key-value pair associated with the key in the bucket.
* If the key does not exist in the bucket, it does nothing.
* If any other error occurs, it returns an `Err(error)`.
* @throws Error
*/
export function delete_(bucket: Bucket, key: Key): void;
/**
* Check if the key exists in the bucket.
* If the key exists in the bucket, it returns `Ok(true)`. If the key does
* not exist in the bucket, it returns `Ok(false)`.
* If any other error occurs, it returns an `Err(error)`.
* @throws Error
*/
export function exists(bucket: Bucket, key: Key): boolean;

export class OutgoingValue {
    static newOutgoingValue(): OutgoingValue;
    /**
     * Writes the value to the output-stream asynchronously.
     * If any other error occurs, it returns an `Err(error)`.
     * @throws Error
     */
    outgoingValueWriteBodyAsync(): OutgoingValueBodyAsync;
    /**
     * Writes the value to the output-stream synchronously.
     * If any other error occurs, it returns an `Err(error)`.
     * @throws Error
     */
    outgoingValueWriteBodySync(value: OutgoingValueBodySync): void;
}
 
export class IncomingValue {
    /**
     * Consumes the value synchronously and returns the value as a list of bytes.
     * If any other error occurs, it returns an `Err(error)`.
     * @throws Error
     */
    incomingValueConsumeSync(): IncomingValueSyncBody;
    /**
     * Consumes the value asynchronously and returns the value as an `input-stream`.
     * If any other error occurs, it returns an `Err(error)`.
     * @throws Error
     */
    incomingValueConsumeAsync(): IncomingValueAsyncBody;
    /**
     * The size of the value in bytes.
     * If the size is unknown or unavailable, this function returns an `Err(error)`.
     * @throws Error
     */
    incomingValueSize(): bigint;
}
 
export type OutgoingValueBodyAsync = OutputStream;
export type OutgoingValueBodySync = Uint8Array;
export type IncomingValueAsyncBody = InputStream;
export type IncomingValueSyncBody = Uint8Array;

declare module 'wasi:blobstore/blobstore' {
    /**
     * creates a new empty container
     * @throws Error
     */
    export function createContainer(name: ContainerName): Container;
    /**
     * retrieves a container by name
     * @throws Error
     */
    export function getContainer(name: ContainerName): Container;
    /**
     * deletes a container and all objects within it
     * @throws Error
     */
    export function deleteContainer(name: ContainerName): void;
    /**
     * returns true if the container exists
     * @throws Error
     */
    export function containerExists(name: ContainerName): boolean;
    /**
     * copies (duplicates) an object, to the same or a different container.
     * returns an error if the target container does not exist.
     * overwrites destination object if it already existed.
     * @throws Error
     */
    export function copyObject(src: ObjectId, dest: ObjectId): void;
    /**
     * moves or renames an object, to the same or a different container
     * returns an error if the destination container does not exist.
     * overwrites destination object if it already existed.
     * @throws Error
     */
    export function moveObject(src: ObjectId, dest: ObjectId): void;
 
    // ...
}

export class Container {
    /**
     * returns container name
     * @throws Error
     */
    name(): string;
    /**
     * returns container metadata
     * @throws Error
     */
    info(): ContainerMetadata;
    /**
     * retrieves an object or portion of an object, as a resource.
     * Start and end offsets are inclusive.
     * Once a data-blob resource has been created, the underlying bytes are held by the blobstore service for the lifetime
     * of the data-blob resource, even if the object they came from is later deleted.
     * @throws Error
     */
    getData(name: ObjectName, start: bigint, end: bigint): IncomingValue;
    /**
     * creates or replaces an object with the data blob.
     * @throws Error
     */
    writeData(name: ObjectName, data: OutgoingValue): void;
    /**
     * returns list of objects in the container. Order is undefined.
     * @throws Error
     */
    listObjects(): StreamObjectNames;
    /**
     * deletes object.
     * does not return error if object did not exist.
     * @throws Error
     */
    deleteObject(name: ObjectName): void;
    /**
     * deletes multiple objects in the container
     * @throws Error
     */
    deleteObjects(names: ObjectName[]): void;
    /**
     * returns true if the object exists in this container
     * @throws Error
     */
    hasObject(name: ObjectName): boolean;
    /**
     * returns metadata for the object
     * @throws Error
     */
    objectInfo(name: ObjectName): ObjectMetadata;
    /**
     * removes all objects within the container, leaving the container empty.
     * @throws Error
     */
    clear(): void;
}