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

// Code generated by zapgen --target=ts; DO NOT EDIT.
// source: folder-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 Folder service (stable wire ids). */
export const FolderMethod = {
  getFolders: 1,
  findFolders: 2,
  findFoldersInternal: 3,
  createFolder: 4,
  updateFolder: 5,
  deleteFolder: 6,
} as const;

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

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

  async getFolders(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: FolderMethod.getFolders,
      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(`Folder.getFolders: status ${resp.status}`);
    }
    return resp.body;
  }

  async findFolders(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: FolderMethod.findFolders,
      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(`Folder.findFolders: status ${resp.status}`);
    }
    return resp.body;
  }

  async findFoldersInternal(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: FolderMethod.findFoldersInternal,
      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(`Folder.findFoldersInternal: status ${resp.status}`);
    }
    return resp.body;
  }

  async createFolder(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: FolderMethod.createFolder,
      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(`Folder.createFolder: status ${resp.status}`);
    }
    return resp.body;
  }

  async updateFolder(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: FolderMethod.updateFolder,
      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(`Folder.updateFolder: status ${resp.status}`);
    }
    return resp.body;
  }

  async deleteFolder(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: FolderMethod.deleteFolder,
      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(`Folder.deleteFolder: status ${resp.status}`);
    }
    return resp.body;
  }

}

/** Abstract RPC server for the Folder service. Subclass and implement each method. */
export abstract class FolderServer {
  abstract getFolders(req: Uint8Array): Promise<Uint8Array>;
  abstract findFolders(req: Uint8Array): Promise<Uint8Array>;
  abstract findFoldersInternal(req: Uint8Array): Promise<Uint8Array>;
  abstract createFolder(req: Uint8Array): Promise<Uint8Array>;
  abstract updateFolder(req: Uint8Array): Promise<Uint8Array>;
  abstract deleteFolder(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 FolderMethod.getFolders: {
        const body = await this.getFolders(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case FolderMethod.findFolders: {
        const body = await this.findFolders(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case FolderMethod.findFoldersInternal: {
        const body = await this.findFoldersInternal(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case FolderMethod.createFolder: {
        const body = await this.createFolder(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case FolderMethod.updateFolder: {
        const body = await this.updateFolder(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case FolderMethod.deleteFolder: {
        const body = await this.deleteFolder(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      default:
        return buildResponse(Status.NotFound, call.promiseID, new Uint8Array(0));
    }
  }
}