Class PubSub (4.4.0)

Package

Examples

Import the client library

const {PubSub} = require('@google-cloud/pubsub');

Create a client that uses Application Default Credentials (ADC):

const pubsub = new PubSub();

Create a client with explicit credentials:

const pubsub = new PubSub({
  projectId: 'your-project-id',
  keyFilename: '/path/to/keyfile.json'
});

Full quickstart example:

// Imports the Google Cloud client library
import {PubSub} from '@google-cloud/pubsub';

async function quickstart(
  projectId = 'your-project-id', // Your Google Cloud Platform project ID
  topicNameOrId = 'my-topic', // Name for the new topic to create
  subscriptionName = 'my-sub' // Name for the new subscription to create
) {
  // Instantiates a client
  const pubsub = new PubSub({projectId});

  // Creates a new topic
  const [topic] = await pubsub.createTopic(topicNameOrId);
  console.log(`Topic ${topic.name} created.`);

  // Creates a subscription on that new topic
  const [subscription] = await topic.createSubscription(subscriptionName);

  // Receive callbacks for new messages on the subscription
  subscription.on('message', message => {
    console.log('Received message:', message.data.toString());
    process.exit(0);
  });

  // Receive callbacks for errors on the subscription
  subscription.on('error', error => {
    console.error('Received error:', error);
    process.exit(1);
  });

  // Send a message to the topic
  topic.publishMessage({data: Buffer.from('Test message!')});
}

Constructors

(constructor)(options)

constructor(options?: ClientConfig);

Properties

api

api: {
        [key: string]: gax.ClientStub;
    };

auth

auth: GoogleAuth;

getSnapshotsStream

getSnapshotsStream: () => ObjectStream<Snapshot>;

getSubscriptionsStream

getSubscriptionsStream: () => ObjectStream<Subscription>;

getTopicsStream

getTopicsStream: () => ObjectStream<Topic>;

isEmulator

isEmulator: boolean;

isIdResolved

get isIdResolved(): boolean;

isOpen

isOpen: boolean;

name

name?: string;

options

options: ClientConfig;

projectId

projectId: string;

Promise

Promise?: PromiseConstructor;

Methods

close()

close(): Promise<void>;

close(callback)

close(callback: EmptyCallback): void;

closeAllClients_()

closeAllClients_(): Promise<void>;

createSchema(schemaId, type, definition, gaxOpts)

createSchema(schemaId: string, type: SchemaType, definition: string, gaxOpts?: CallOptions): Promise<Schema>;

Create a schema.

const {PubSub} = require('@google-cloud/pubsub');
const pubsub = new PubSub();

await pubsub.createSchema(
  'messageType',
  SchemaTypes.Avro,
  '{...avro definition...}'
);

createSubscription(topic, name, options)

createSubscription(topic: Topic | string, name: string, options?: CreateSubscriptionOptions): Promise<CreateSubscriptionResponse>;

Subscribe to a topic.

const {PubSub} = require('@google-cloud/pubsub');
const pubsub = new PubSub();

const topic = 'messageCenter';
const name = 'newMessages';

const callback = function(err, subscription, apiResponse) {};

pubsub.createSubscription(topic, name, callback);

If the callback is omitted, we'll return a Promise.

pubsub.createSubscription(topic, name)
  .then(function(data) {
    const subscription = data[0];
    const apiResponse = data[1];
  });

createSubscription(topic, name, callback)

createSubscription(topic: Topic | string, name: string, callback: CreateSubscriptionCallback): void;

createSubscription(topic, name, options, callback)

createSubscription(topic: Topic | string, name: string, options: CreateSubscriptionOptions, callback: CreateSubscriptionCallback): void;

createTopic(name, gaxOpts)

createTopic(name: string | TopicMetadata, gaxOpts?: CallOptions): Promise<CreateTopicResponse>;

const {PubSub} = require('@google-cloud/pubsub');
const pubsub = new PubSub();

pubsub.createTopic('my-new-topic', function(err, topic, apiResponse) {
  if (!err) {
    // The topic was created successfully.
  }
});

//-
// If the callback is omitted, we'll return a Promise.
//-
pubsub.createTopic('my-new-topic').then(function(data) {
  const topic = data[0];
  const apiResponse = data[1];
});

createTopic(name, callback)

createTopic(name: string | TopicMetadata, callback: CreateTopicCallback): void;

createTopic(name, gaxOpts, callback)

createTopic(name: string | TopicMetadata, gaxOpts: CallOptions, callback: CreateTopicCallback): void;

detachSubscription(name, gaxOpts)

detachSubscription(name: string, gaxOpts?: CallOptions): Promise<DetachSubscriptionResponse>;

const {PubSub} = require('@google-cloud/pubsub');
const pubsub = new PubSub();

pubsub.detachSubscription('my-sub', (err, topic, apiResponse) => {
  if (!err) {
    // The topic was created successfully.
  }
});

//-
// If the callback is omitted, we'll return a Promise.
//-
pubsub.detachSubscription('my-sub').then(data => {
  const apiResponse = data[0];
});

detachSubscription(name, callback)

detachSubscription(name: string, callback: DetachSubscriptionCallback): void;

detachSubscription(name, gaxOpts, callback)

detachSubscription(name: string, gaxOpts: CallOptions, callback: DetachSubscriptionCallback): void;

determineBaseUrl_()

determineBaseUrl_(): void;

formatName_(name)

static formatName_(name: string): string;

getClient_(config, callback)

getClient_(config: GetClientConfig, callback: GetClientCallback): void;

getClientAsync_(config)

getClientAsync_(config: GetClientConfig): Promise<gax.ClientStub>;

getClientConfig()

getClientConfig(): Promise<ClientConfig>;

getSchemaClient()

getSchemaClient(): Promise<SchemaServiceClient>;

getSnapshots(options)

getSnapshots(options?: PageOptions): Promise<GetSnapshotsResponse>;

const {PubSub} = require('@google-cloud/pubsub');
const pubsub = new PubSub();

pubsub.getSnapshots(function(err, snapshots) {
  if (!err) {
    // snapshots is an array of Snapshot objects.
  }
});

//-
// If the callback is omitted, we'll return a Promise.
//-
pubsub.getSnapshots().then(function(data) {
  const snapshots = data[0];
});

getSnapshots(callback)

getSnapshots(callback: GetSnapshotsCallback): void;

getSnapshots(options, callback)

getSnapshots(options: PageOptions, callback: GetSnapshotsCallback): void;

getSubscriptions(options)

getSubscriptions(options?: GetSubscriptionsOptions): Promise<GetSubscriptionsResponse>;

const {PubSub} = require('@google-cloud/pubsub');
const pubsub = new PubSub();

pubsub.getSubscriptions(function(err, subscriptions) {
  if (!err) {
    // subscriptions is an array of Subscription objects.
  }
});

//-
// If the callback is omitted, we'll return a Promise.
//-
pubsub.getSubscriptions().then(function(data) {
  const subscriptions = data[0];
});

getSubscriptions(callback)

getSubscriptions(callback: GetSubscriptionsCallback): void;

getSubscriptions(options, callback)

getSubscriptions(options: GetSubscriptionsOptions, callback: GetSubscriptionsCallback): void;

getTopics(options)

getTopics(options?: PageOptions): Promise<GetTopicsResponse>;

const {PubSub} = require('@google-cloud/pubsub');
const pubsub = new PubSub();

pubsub.getTopics(function(err, topics) {
  if (!err) {
    // topics is an array of Topic objects.
  }
});

//-
// Customize the query.
//-
pubsub.getTopics({
  pageSize: 3
}, function(err, topics) {});

//-
// If the callback is omitted, we'll return a Promise.
//-
pubsub.getTopics().then(function(data) {
  const topics = data[0];
});

getTopics(callback)

getTopics(callback: GetTopicsCallback): void;

getTopics(options, callback)

getTopics(options: PageOptions, callback: GetTopicsCallback): void;

listSchemas(view, options)

listSchemas(view?: SchemaView, options?: CallOptions): AsyncIterable<google.pubsub.v1.ISchema>;

for await (const s of pubsub.listSchemas()) {
  const moreInfo = await s.get();
}

request(config, callback)

request<T, R = void>(config: RequestConfig, callback: RequestCallback<T, R>): void;

schema(idOrName)

schema(idOrName: string): Schema;

const {PubSub} = require('@google-cloud/pubsub');
const pubsub = new PubSub();

const schema = pubsub.schema('my-schema');

snapshot(name)

snapshot(name: string): Snapshot;

const {PubSub} = require('@google-cloud/pubsub');
const pubsub = new PubSub();

const snapshot = pubsub.snapshot('my-snapshot');

subscription(name, options)

subscription(name: string, options?: SubscriptionOptions): Subscription;

const {PubSub} = require('@google-cloud/pubsub');
const pubsub = new PubSub();

const subscription = pubsub.subscription('my-subscription');

// Register a listener for `message` events.
subscription.on('message', function(message) {
  // Called every time a message is received.
  // message.id = ID of the message.
  // message.ackId = ID used to acknowledge the message receival.
  // message.data = Contents of the message.
  // message.attributes = Attributes of the message.
  // message.publishTime = Date when Pub/Sub received the message.
});

topic(name, options)

topic(name: string, options?: PublishOptions): Topic;

const {PubSub} = require('@google-cloud/pubsub');
const pubsub = new PubSub();

const topic = pubsub.topic('my-topic');

validateSchema(schema, gaxOpts)

validateSchema(schema: ISchema, gaxOpts?: CallOptions): Promise<void>;