componentized

composition componentized:services-valkey-credential-admin@0.0.2

Composition

WIT

package root:component;

world root {
  import componentized:services/types;
  import wasi:config/store@0.2.0-draft;
  import wasi:sockets/network@0.2.3;
  import wasi:sockets/instance-network@0.2.3;
  import wasi:io/poll@0.2.3;
  import wasi:io/error@0.2.3;
  import wasi:io/streams@0.2.3;
  import wasi:sockets/tcp@0.2.3;
  import wasi:sockets/tcp-create-socket@0.2.3;
  import wasi:sockets/ip-name-lookup@0.2.3;

  export componentized:services/credential-admin;
}
The WIT of its dependencies, as it was built against them

This version keeps the parts of its dependencies it uses, as they were when it was built: their indexed versions differ from them, e.g. a pre-release that has since moved, or aren't indexed.

package componentized:services {
  interface types {
    type service-binding-id = string;

    record credential {
      key: string,
      value: string,
    }

    type error = string;
  }
  interface credential-admin {
    use types.{service-binding-id, credential, error};

    publish: func(binding-id: service-binding-id, credentials: list<credential>) -> result<_, error>;

    destroy: func(binding-id: service-binding-id) -> result<_, error>;
  }
}


package wasi:config@0.2.0-draft {
  interface store {
    variant error {
      upstream(string),
      io(string),
    }

    get: func(key: string) -> result<option<string>, error>;
  }
}


package wasi:io@0.2.3 {
  interface poll {
    resource pollable {
      block: func();
    }
  }
  interface error {
    resource error {
      to-debug-string: func() -> string;
    }
  }
  interface streams {
    use error.{error};

    resource input-stream {
      blocking-read: func(len: u64) -> result<list<u8>, stream-error>;
    }

    variant stream-error {
      last-operation-failed(error),
      closed,
    }

    resource output-stream {
      blocking-write-and-flush: func(contents: list<u8>) -> result<_, stream-error>;
    }
  }
}


package wasi:sockets@0.2.3 {
  interface network {
    resource network;

    type ipv4-address = tuple<u8, u8, u8, u8>;

    record ipv4-socket-address {
      port: u16,
      address: ipv4-address,
    }

    type ipv6-address = tuple<u16, u16, u16, u16, u16, u16, u16, u16>;

    record ipv6-socket-address {
      port: u16,
      flow-info: u32,
      address: ipv6-address,
      scope-id: u32,
    }

    variant ip-socket-address {
      ipv4(ipv4-socket-address),
      ipv6(ipv6-socket-address),
    }

    enum error-code {
      unknown,
      access-denied,
      not-supported,
      invalid-argument,
      out-of-memory,
      timeout,
      concurrency-conflict,
      not-in-progress,
      would-block,
      invalid-state,
      new-socket-limit,
      address-not-bindable,
      address-in-use,
      remote-unreachable,
      connection-refused,
      connection-reset,
      connection-aborted,
      datagram-too-large,
      name-unresolvable,
      temporary-resolver-failure,
      permanent-resolver-failure,
    }

    enum ip-address-family {
      ipv4,
      ipv6,
    }

    variant ip-address {
      ipv4(ipv4-address),
      ipv6(ipv6-address),
    }
  }
  interface instance-network {
    use network.{network};

    instance-network: func() -> network;
  }
  interface tcp {
    use network.{network, ip-socket-address, error-code};
    use wasi:io/streams@0.2.3.{input-stream, output-stream};
    use wasi:io/poll@0.2.3.{pollable};

    resource tcp-socket {
      start-connect: func(network: borrow<network>, remote-address: ip-socket-address) -> result<_, error-code>;
      finish-connect: func() -> result<tuple<input-stream, output-stream>, error-code>;
      subscribe: func() -> pollable;
    }
  }
  interface tcp-create-socket {
    use network.{ip-address-family};
    use tcp.{tcp-socket};
    use network.{error-code};

    create-tcp-socket: func(address-family: ip-address-family) -> result<tcp-socket, error-code>;
  }
  interface ip-name-lookup {
    use network.{ip-address, error-code};
    use wasi:io/poll@0.2.3.{pollable};
    use network.{network};

    resource resolve-address-stream {
      resolve-next-address: func() -> result<option<ip-address>, error-code>;
      subscribe: func() -> pollable;
    }

    resolve-addresses: func(network: borrow<network>, name: string) -> result<resolve-address-stream, error-code>;
  }
}