esign/packages/trpc/zap/gen/webhook-router_zap.ts

// Code generated by zapgen --target=ts; DO NOT EDIT.
// source: webhook-router.zap

import {
  Builder,
  Message,
  StructView,
  buildRequest,
  parseRequest,
  buildResponse,
  NO_TARGET,
  Status,
  type Call,
  type Response,
} from "@zap-proto/zap";

const reqOff = {
  Body: 0,
} as const;
const reqSize = 8;

/** Zero-copy view into a ZAP-encoded Req message. */
export class Req extends StructView {
  /** Parse `b` and return a typed view. Throws on a wire-level check failure (magic, version, size). */
  static wrap(b: Uint8Array): Req {
    const root = Message.parse(b).root();
    return new Req(root.data, root.offset);
  }

  get body(): string { return this.text(reqOff.Body); }
}

/** Field values for newReq. */
export interface ReqInput {
  body: string;
}

/** Build a ZAP-encoded Req message from `in` and return the bytes. */
export function newReq(in_: ReqInput): Uint8Array {
  const b = new Builder(256);
  const ob = b.startObject(reqSize);
  ob.setText(reqOff.Body, in_.body);
  ob.finishAsRoot();
  return b.finish();
}


const respOff = {
  Body: 0,
} as const;
const respSize = 8;

/** Zero-copy view into a ZAP-encoded Resp message. */
export class Resp extends StructView {
  /** Parse `b` and return a typed view. Throws on a wire-level check failure (magic, version, size). */
  static wrap(b: Uint8Array): Resp {
    const root = Message.parse(b).root();
    return new Resp(root.data, root.offset);
  }

  get body(): string { return this.text(respOff.Body); }
}

/** Field values for newResp. */
export interface RespInput {
  body: string;
}

/** Build a ZAP-encoded Resp message from `in` and return the bytes. */
export function newResp(in_: RespInput): Uint8Array {
  const b = new Builder(256);
  const ob = b.startObject(respSize);
  ob.setText(respOff.Body, in_.body);
  ob.finishAsRoot();
  return b.finish();
}


/** Method ordinals for the Webhook service (stable wire ids). */
export const WebhookMethod = {
  callsFind: 1,
  callsResend: 2,
  getTeamWebhooks: 3,
  getWebhookById: 4,
  createWebhook: 5,
  deleteWebhook: 6,
  editWebhook: 7,
  testWebhook: 8,
} as const;

/** Typed RPC client for the Webhook service over a ZAP call channel. */
export interface WebhookChannel {
  /** Ship one Call envelope and await its correlated Response. */
  call(envelope: Uint8Array): Promise<Response>;
}

export class WebhookClient {
  constructor(private readonly channel: WebhookChannel, private readonly cap: Uint8Array = new Uint8Array(0)) {}

  async callsFind(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: WebhookMethod.callsFind,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Webhook.callsFind: status ${resp.status}`);
    }
    return resp.body;
  }

  async callsResend(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: WebhookMethod.callsResend,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Webhook.callsResend: status ${resp.status}`);
    }
    return resp.body;
  }

  async getTeamWebhooks(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: WebhookMethod.getTeamWebhooks,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Webhook.getTeamWebhooks: status ${resp.status}`);
    }
    return resp.body;
  }

  async getWebhookById(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: WebhookMethod.getWebhookById,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Webhook.getWebhookById: status ${resp.status}`);
    }
    return resp.body;
  }

  async createWebhook(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: WebhookMethod.createWebhook,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Webhook.createWebhook: status ${resp.status}`);
    }
    return resp.body;
  }

  async deleteWebhook(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: WebhookMethod.deleteWebhook,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Webhook.deleteWebhook: status ${resp.status}`);
    }
    return resp.body;
  }

  async editWebhook(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: WebhookMethod.editWebhook,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Webhook.editWebhook: status ${resp.status}`);
    }
    return resp.body;
  }

  async testWebhook(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: WebhookMethod.testWebhook,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Webhook.testWebhook: status ${resp.status}`);
    }
    return resp.body;
  }

}

/** Abstract RPC server for the Webhook service. Subclass and implement each method. */
export abstract class WebhookServer {
  abstract callsFind(req: Uint8Array): Promise<Uint8Array>;
  abstract callsResend(req: Uint8Array): Promise<Uint8Array>;
  abstract getTeamWebhooks(req: Uint8Array): Promise<Uint8Array>;
  abstract getWebhookById(req: Uint8Array): Promise<Uint8Array>;
  abstract createWebhook(req: Uint8Array): Promise<Uint8Array>;
  abstract deleteWebhook(req: Uint8Array): Promise<Uint8Array>;
  abstract editWebhook(req: Uint8Array): Promise<Uint8Array>;
  abstract testWebhook(req: Uint8Array): Promise<Uint8Array>;

  /** Decode a Call envelope, route by method ordinal, and build the Response envelope. */
  async dispatch(envelope: Uint8Array): Promise<Uint8Array> {
    const call: Call = parseRequest(envelope);
    switch (call.method) {
      case WebhookMethod.callsFind: {
        const body = await this.callsFind(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case WebhookMethod.callsResend: {
        const body = await this.callsResend(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case WebhookMethod.getTeamWebhooks: {
        const body = await this.getTeamWebhooks(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case WebhookMethod.getWebhookById: {
        const body = await this.getWebhookById(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case WebhookMethod.createWebhook: {
        const body = await this.createWebhook(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case WebhookMethod.deleteWebhook: {
        const body = await this.deleteWebhook(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case WebhookMethod.editWebhook: {
        const body = await this.editWebhook(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case WebhookMethod.testWebhook: {
        const body = await this.testWebhook(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      default:
        return buildResponse(Status.NotFound, call.promiseID, new Uint8Array(0));
    }
  }
}