@fonoster/sdk 0.6.0 → 0.6.1

package/dist/node/Applications.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Applications = void 0;
+const makeRpcRequest_1 = require("./client/makeRpcRequest");
+const applications_pb_1 = require("./generated/node/applications_pb");
+const utils_1 = require("./utils");
+/**
+ * @classdesc Fonoster Applications, part of the Fonoster Voice Subsystem,
+ * allow you to create, update, retrieve, and delete Voice Applications.
+ * Note that an active Fonoster deployment is required.
+ *
+ * @example
+ *
+ * const SDK = require("@fonoster/sdk");
+ *
+ * const request = {
+ *   name: "My application",
+ *   type: "PROGRAMMABLE_VOICE",
+ *   appEndpoint: "myapp.mydomain.com",
+ *   textToSpeech: {
+ *     productRef: "tts.google",
+ *     config: {
+ *       voice: "en-US-Casual-K"
+ *     }
+ *   },
+ *   speechToText: {
+ *     productRef: "stt.google",
+ *     config: {
+ *      languageCode: "en-US"
+ *     }
+ *   },
+ *   intelligence: {
+ *     productRef: "nlu.dialogflowcx",
+ *     credentials: {
+ *        apiKey: "your-api-key"
+ *     },
+ *     config: {
+ *       agentId: "your-agent-id"
+ *     }
+ *   }
+ * };
+ *
+ * const username = "admin@fonoster.local";
+ * const password = "changeme";
+ * const accessKeyId = "WO00000000000000000000000000000000";
+ *
+ * const client = new SDK.Client({ accessKeyId });
+ *
+ * client.login(username, password)
+ *  .then(async () => {
+ *    const apps = new SDK.Applications(client);
+ *    const result = await apps.createApplication(request);
+ *    console.log(result);  // successful response
+ *  }).catch(console.error); // an error occurred
+ */
+class Applications {
+    client;
+    /**
+     * Constructs a new Applications object.
+     *
+     * @param {FonosterClient} client - Client object with underlying implementations to make requests to Fonoster's API
+     * @see AbstractClient
+     * @see FonosterClient
+     */
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Creates a new Application in Fonoster. The only required fields are the name and type of the application.
+     *
+     * @param {CreateApplicationRequest} request - The request object that contains the necessary information to create a new application
+     * @param {string} request.name - The name of the application
+     * @param {ApplicationType} request.type - The type of application (e.g., PROGRAMMABLE_VOICE)
+     * @param {string} request.appEndpoint - The endpoint where the application is hosted
+     * @param {TextToSpeech} request.textToSpeech - The text-to-speech configuration
+     * @param {string} request.textToSpeech.productRef - The product reference of the text-to-speech engine (e.g., tts.google)
+     * @param {object} request.textToSpeech.config - The configuration object for the text-to-speech engine (e.g., { voice: "en-US-Casual-K" })
+     * @param {SpeechToText} request.speechToText - The speech-to-text configuration
+     * @param {string} request.speechToText.productRef - The product reference of the speech-to-text engine (e.g., stt.google)
+     * @param {object} request.speechToText.config - The configuration object for the speech-to-text engine (e.g., { languageCode: "en-US" })
+     * @param {Intelligence} request.intelligence - The intelligence configuration
+     * @param {string} request.intelligence.productRef - The product reference of the intelligence engine (e.g., nlu.dialogflowcx)
+     * @param {object} request.intelligence.credentials - The credentials object for the intelligence engine (e.g., { apiKey: "your-api-key" })
+     * @param {object} request.intelligence.config - The configuration object for the intelligence engine (e.g., { agentId: "your-agent-id" })
+     * @return {Promise<CreateAppResponse>} - The response object that contains the reference to the newly created application
+     * @example
+     *
+     * const request = {
+     *   name: "My application",
+     *   type: "PROGRAMMABLE_VOICE",
+     *   appEndpoint: "myapp.mydomain.com",
+     *   textToSpeech: {
+     *     productRef: "tts.google",
+     *     config: {
+     *       voice: "en-US-Casual-K"
+     *     }
+     *   },
+     *   speechToText: {
+     *     productRef: "stt.google",
+     *     config: {
+     *      languageCode: "en-US"
+     *     }
+     *   },
+     *   intelligence: {
+     *     productRef: "nlu.dialogflowcx",
+     *     credentials: {
+     *        apiKey: "your-api-key"
+     *     },
+     *     config: {
+     *       agentId: "your-agent-id"
+     *     }
+     *   }
+     * };
+     *
+     * const apps = new SDK.Applications(client); // Existing client object
+     *
+     * apps.createApplication(request)
+     *  .then(console.log) // successful response
+     *  .catch(console.error); // an error occurred
+     */
+    async createApplication(request) {
+        const reqWithStructOverride = (0, utils_1.buildStructOverride)(request);
+        const applicationsClient = this.client.getApplicationsClient();
+        return await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: applicationsClient.createApplication.bind(applicationsClient),
+            requestPBObjectConstructor: applications_pb_1.CreateApplicationRequest,
+            metadata: this.client.getMetadata(),
+            request: reqWithStructOverride,
+            enumMapping: [["type", applications_pb_1.ApplicationType]],
+            objectMapping: [
+                ["textToSpeech", applications_pb_1.ProductContainer],
+                ["speechToText", applications_pb_1.ProductContainer],
+                ["intelligence", applications_pb_1.ProductContainer]
+            ]
+        });
+    }
+    /**
+     * Retrieves an existing application from Fonoster.
+     *
+     * @param {string} ref - The reference of the application to retrieve
+     * @return {Promise<Application>} - The response object that contains the application information
+     * @example
+     *
+     * const request = {
+     *  ref: "00000000-0000-0000-0000-000000000000"
+     * };
+     *
+     * const apps = new SDK.Applications(client); // Existing client object
+     *
+     * apps.getApplication(request)
+     *  .then(console.log) // successful response
+     *  .catch(console.error); // an error occurred
+     */
+    async getApplication(ref) {
+        const applicationsClient = this.client.getApplicationsClient();
+        return await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: applicationsClient.getApplication.bind(applicationsClient),
+            requestPBObjectConstructor: applications_pb_1.GetApplicationRequest,
+            metadata: this.client.getMetadata(),
+            request: { ref }
+        });
+    }
+    /**
+     * Updates an existing application in Fonoster.
+     *
+     * @param {UpdateApplicationRequest} request - The request object that contains the necessary information to update an application
+     * @param {string} request.ref - The reference of the application to update
+     * @param {string} request.name - The name of the application
+     * @param {string} request.appEndpoint - The endpoint where the application is hosted
+     * @param {TextToSpeech} request.textToSpeech - The text-to-speech configuration
+     * @param {string} request.textToSpeech.productRef - The product reference of the text-to-speech engine (e.g., tts.google)
+     * @param {object} request.textToSpeech.config - The configuration object for the text-to-speech engine (e.g., { voice: "en-US-Casual-K" })
+     * @param {SpeechToText} request.speechToText - The speech-to-text configuration
+     * @param {string} request.speechToText.productRef - The product reference of the speech-to-text engine (e.g., stt.google)
+     * @param {object} request.speechToText.config - The configuration object for the speech-to-text engine (e.g., { languageCode: "en-US" })
+     * @param {Intelligence} request.intelligence - The intelligence configuration
+     * @param {string} request.intelligence.productRef - The product reference of the intelligence engine (e.g., nlu.dialogflowcx)
+     * @param {object} request.intelligence.credentials - The credentials object for the intelligence engine (e.g., { apiKey: "your-api-key" })
+     * @param {object} request.intelligence.config - The configuration object for the intelligence engine (e.g., { agentId: "your-agent-id" })
+     * @return {Promise<BaseApiObject>} - The response object that contains the reference to the updated application
+     * @example
+     *
+     * const request = {
+     *  ref: "00000000-0000-0000-0000-000000000000",
+     *  name: "My application",
+     *  appEndpoint: "myapp.mydomain.com"
+     * }
+     *
+     * const apps = new SDK.Applications(client); // Existing client object
+     *
+     * apps.updateApplication(request)
+     *  .then(console.log) // successful response
+     *  .catch(console.error); // an error occurred
+     */
+    async updateApplication(request) {
+        const reqWithStructOverride = (0, utils_1.buildStructOverride)(request);
+        const applicationsClient = this.client.getApplicationsClient();
+        return await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: applicationsClient.updateApplication.bind(applicationsClient),
+            requestPBObjectConstructor: applications_pb_1.UpdateApplicationRequest,
+            metadata: this.client.getMetadata(),
+            request: reqWithStructOverride,
+            enumMapping: [["type", applications_pb_1.ApplicationType]],
+            objectMapping: [
+                ["textToSpeech", applications_pb_1.ProductContainer],
+                ["speechToText", applications_pb_1.ProductContainer],
+                ["intelligence", applications_pb_1.ProductContainer]
+            ]
+        });
+    }
+    /**
+     * Retrieves a list of applications from Fonoster.
+     *
+     * @param {ListApplicationsRequest} request - The request object that contains the necessary information to retrieve a list of applications
+     * @param {number} request.pageSize - The number of applications to retrieve
+     * @param {string} request.pageToken - The token to retrieve the next page of applications
+     * @return {Promise<ListApplicationsResponse>} - The response object that contains the list of applications
+     * @example
+     *
+     * const request = {
+     *  pageSize: 10,
+     *  pageToken: "00000000-0000-0000-0000-000000000000"
+     * };
+     *
+     * const apps = new SDK.Applications(client); // Existing client object
+     *
+     * apps.listApplications(request)
+     *  .then(console.log) // successful response
+     *  .catch(console.error); // an error occurred
+     */
+    async listApplications(request) {
+        const applicationsClient = this.client.getApplicationsClient();
+        return await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: applicationsClient.listApplications.bind(applicationsClient),
+            requestPBObjectConstructor: applications_pb_1.ListApplicationsRequest,
+            metadata: this.client.getMetadata(),
+            request,
+            repeatableObjectMapping: [["itemsList", applications_pb_1.Application]]
+        });
+    }
+    /**
+     * Deletes an existing application from Fonoster.
+     * Note that this operation is irreversible.
+     *
+     * @param {string} ref - The reference of the application to delete
+     * @return {Promise<BaseApiObject>} - The response object that contains the reference to the deleted application
+     * @example
+     *
+     * const ref =  "00000000-0000-0000-0000-000000000000"
+     *
+     * const apps = new SDK.Applications(client); // Existing client object
+     *
+     * apps.deleteApplication(ref)
+     *  .then(console.log) // successful response
+     *  .catch(console.error); // an error occurred
+     */
+    async deleteApplication(ref) {
+        const applicationsClient = this.client.getApplicationsClient();
+        return await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: applicationsClient.deleteApplication.bind(applicationsClient),
+            requestPBObjectConstructor: applications_pb_1.DeleteApplicationRequest,
+            metadata: this.client.getMetadata(),
+            request: { ref }
+        });
+    }
+}
+exports.Applications = Applications;

package/dist/node/client/AbstractClient.d.ts

@@ -0,0 +1,22 @@
+import { ApplicationsClient, FonosterClient, IdentityClient } from "./types";
+declare abstract class AbstractClient implements FonosterClient {
+    protected idToken: string;
+    protected accessKeyId: string;
+    protected _accessToken: string;
+    protected _refreshToken: string;
+    protected identityClient: IdentityClient;
+    constructor(config: {
+        accessKeyId: string;
+        identityClient: IdentityClient;
+    });
+    login(username: string, password: string): Promise<void>;
+    loginWithRefreshToken(refreshToken: string): Promise<void>;
+    loginWithApiKey(apiKey: string): Promise<void>;
+    refreshToken(): Promise<void>;
+    getAccessKeyId(): string;
+    getAccessToken(): string;
+    getRefreshToken(): string;
+    abstract getMetadata(): unknown;
+    abstract getApplicationsClient(): ApplicationsClient;
+}
+export { AbstractClient };

package/dist/node/client/AbstractClient.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractClient = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const makeRpcRequest_1 = require("./makeRpcRequest");
+const identity_pb_1 = require("../generated/node/identity_pb");
+class AbstractClient {
+    idToken;
+    accessKeyId;
+    _accessToken;
+    _refreshToken;
+    identityClient;
+    constructor(config) {
+        this.accessKeyId = config.accessKeyId;
+        this.identityClient = config.identityClient;
+        this._accessToken = "";
+        this._refreshToken = "";
+    }
+    async login(username, password) {
+        const { refreshToken, accessToken } = await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: this.identityClient.exchangeCredentials.bind(this.identityClient),
+            requestPBObjectConstructor: identity_pb_1.ExchangeCredentialsRequest,
+            metadata: {},
+            request: {
+                username,
+                password
+            }
+        });
+        this._refreshToken = refreshToken;
+        this._accessToken = accessToken;
+    }
+    async loginWithRefreshToken(refreshToken) {
+        const { accessToken, refreshToken: newRefreshToken } = await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: this.identityClient.exchangeRefreshToken.bind(this.identityClient),
+            requestPBObjectConstructor: identity_pb_1.ExchangeRefreshTokenRequest,
+            metadata: {},
+            request: {
+                refreshToken
+            }
+        });
+        this._refreshToken = newRefreshToken;
+        this._accessToken = accessToken;
+    }
+    async loginWithApiKey(apiKey) {
+        const { refreshToken, accessToken } = await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: this.identityClient.exchangeApiKey,
+            requestPBObjectConstructor: identity_pb_1.ExchangeApiKeyRequest,
+            metadata: {},
+            request: {
+                apiKey
+            }
+        });
+        this._refreshToken = refreshToken;
+        this._accessToken = accessToken;
+    }
+    async refreshToken() {
+        return await this.loginWithRefreshToken(this._refreshToken);
+    }
+    getAccessKeyId() {
+        return this.accessKeyId;
+    }
+    getAccessToken() {
+        return this._accessToken;
+    }
+    getRefreshToken() {
+        return this._refreshToken;
+    }
+}
+exports.AbstractClient = AbstractClient;

package/dist/node/client/Client.d.ts

@@ -0,0 +1,15 @@
+import { Metadata } from "@grpc/grpc-js";
+import { AbstractClient } from "./AbstractClient";
+export declare class Client extends AbstractClient {
+    private endpoint;
+    private tokenRefresherInterceptor;
+    private channelCredentials;
+    constructor(config: {
+        endpoint?: string;
+        accessKeyId: string;
+        allowInsecure?: boolean;
+    });
+    getMetadata(): Metadata;
+    getApplicationsClient(): any;
+    getIdentityClient(): any;
+}

package/dist/node/client/Client.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const grpc_js_1 = require("@grpc/grpc-js");
+const AbstractClient_1 = require("./AbstractClient");
+const TokenRefresherNode_1 = require("./TokenRefresherNode");
+const applications_grpc_pb_1 = require("../generated/node/applications_grpc_pb");
+const identity_grpc_pb_1 = require("../generated/node/identity_grpc_pb");
+const DEFAULT_ENDPOINT = "api.fonoster.io:50051";
+class Client extends AbstractClient_1.AbstractClient {
+    endpoint;
+    tokenRefresherInterceptor;
+    channelCredentials;
+    constructor(config) {
+        const channelCredentials = config.allowInsecure
+            ? grpc_js_1.credentials.createInsecure()
+            : grpc_js_1.credentials.createSsl();
+        super({
+            accessKeyId: config.accessKeyId,
+            identityClient: new identity_grpc_pb_1.IdentityClient(config.endpoint, channelCredentials)
+        });
+        this.channelCredentials = channelCredentials;
+        this.endpoint = config?.endpoint || DEFAULT_ENDPOINT;
+        this.tokenRefresherInterceptor = new TokenRefresherNode_1.TokenRefresherNode(this)
+            .createInterceptor()
+            .bind(this);
+    }
+    getMetadata() {
+        const metadata = new grpc_js_1.Metadata();
+        metadata.set("token", this.getAccessToken());
+        metadata.set("accessKeyId", this.getAccessKeyId());
+        return metadata;
+    }
+    getApplicationsClient() {
+        return new applications_grpc_pb_1.ApplicationsClient(this.endpoint, this.channelCredentials, {
+            interceptors: [this.tokenRefresherInterceptor]
+        });
+    }
+    getIdentityClient() {
+        return new identity_grpc_pb_1.IdentityClient(this.endpoint, this.channelCredentials);
+    }
+}
+exports.Client = Client;

package/dist/node/client/TokenRefresherNode.d.ts

@@ -0,0 +1,8 @@
+import { Interceptor } from "@grpc/grpc-js";
+import { AbstractClient } from "./AbstractClient";
+declare class TokenRefresherNode {
+    private client;
+    constructor(client: AbstractClient);
+    createInterceptor(): Interceptor;
+}
+export { TokenRefresherNode };

package/dist/node/client/TokenRefresherNode.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenRefresherNode = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const grpc_js_1 = require("@grpc/grpc-js");
+const isJwtExpired_1 = require("./isJwtExpired");
+class TokenRefresherNode {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    createInterceptor() {
+        return (options, nextCall) => {
+            return new grpc_js_1.InterceptingCall(nextCall(options), {
+                sendMessage: async (message, next) => {
+                    const token = this.client.getRefreshToken();
+                    if ((0, isJwtExpired_1.isJwtExpired)(token)) {
+                        await this.client.refreshToken();
+                    }
+                    next(message);
+                }
+            });
+        };
+    }
+}
+exports.TokenRefresherNode = TokenRefresherNode;

package/dist/node/client/TokenRefresherWeb.d.ts

@@ -0,0 +1,13 @@
+import * as grpcWeb from "grpc-web";
+import { AbstractClient } from "./AbstractClient";
+type ClientReadableStream = grpcWeb.ClientReadableStream<unknown>;
+declare class TokenRefresherWeb {
+    private client;
+    constructor(client: AbstractClient);
+    intercept(request: unknown, invoker: (request: unknown) => ClientReadableStream): {
+        refresher: TokenRefresherWeb;
+        stream: ClientReadableStream;
+        on(eventType: string, callback: () => void): any;
+    };
+}
+export { TokenRefresherWeb };

package/dist/node/client/TokenRefresherWeb.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenRefresherWeb = void 0;
+const isJwtExpired_1 = require("./isJwtExpired");
+class TokenRefresherWeb {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    intercept(request, invoker) {
+        class InterceptedStream {
+            refresher;
+            stream;
+            constructor(stream, refresher) {
+                this.stream = stream;
+                this.refresher = refresher;
+            }
+            on(eventType, callback) {
+                const token = this.refresher.client.getRefreshToken();
+                if ((0, isJwtExpired_1.isJwtExpired)(token)) {
+                    this.refresher.client.refreshToken().then(() => { });
+                }
+                if (eventType == "data") {
+                    this.stream.on(eventType, callback);
+                }
+                else if (eventType == "error") {
+                    this.stream.on("error", callback);
+                }
+                else if (eventType == "metadata") {
+                    this.stream.on("metadata", callback);
+                }
+                else if (eventType == "status") {
+                    this.stream.on("status", callback);
+                }
+                else if (eventType == "end") {
+                    this.stream.on("end", callback);
+                }
+                return this;
+            }
+        }
+        return new InterceptedStream(invoker(request), this);
+    }
+}
+exports.TokenRefresherWeb = TokenRefresherWeb;

package/dist/node/client/isJwtExpired.d.ts

@@ -0,0 +1,2 @@
+declare function isJwtExpired(token: string): boolean;
+export { isJwtExpired };

package/dist/node/client/isJwtExpired.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJwtExpired = isJwtExpired;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function isJwtExpired(token) {
+    try {
+        const [, payloadBase64] = token.split(".");
+        const payloadJson = Buffer.from(payloadBase64, "base64").toString("utf8");
+        const payload = JSON.parse(payloadJson);
+        if (!payload.exp) {
+            return false;
+        }
+        const expirationTime = payload.exp * 1000;
+        const currentTime = Date.now();
+        return currentTime > expirationTime;
+    }
+    catch (error) {
+        return true;
+    }
+}

package/dist/node/client/jsonToObject.d.ts

@@ -0,0 +1,8 @@
+import { MappingTuple } from "./types";
+declare function jsonToObject<J extends Record<string, unknown>, T>(params: {
+    json: J;
+    objectConstructor: new () => T;
+    enumMapping?: MappingTuple<unknown>;
+    objectMapping?: MappingTuple<unknown>;
+}): T;
+export { jsonToObject };

package/dist/node/client/jsonToObject.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonToObject = jsonToObject;
+const utils_1 = require("./utils");
+function jsonToObject(params) {
+    const { json, objectConstructor: ObjectConstructor, enumMapping, objectMapping } = params;
+    const instance = new ObjectConstructor();
+    Object.keys(json).forEach((key) => {
+        const setterName = `set${key.charAt(0).toUpperCase() + key.slice(1)}`;
+        if (!json[key]) {
+            return;
+        }
+        if ((0, utils_1.isMapping)(key, enumMapping)) {
+            const enumValue = (0, utils_1.getEnumValue)(key, json[key], enumMapping);
+            instance[setterName](enumValue);
+        }
+        else if ((0, utils_1.isMapping)(key, objectMapping)) {
+            const objectValue = jsonToObject({
+                json: json[key],
+                objectConstructor: objectMapping.find((tuple) => tuple[0] === key)[1],
+                enumMapping,
+                objectMapping
+            });
+            instance[setterName](objectValue);
+        }
+        else if (typeof instance[setterName] === "function") {
+            instance[setterName](json[key]);
+        }
+    });
+    return instance;
+}

package/dist/node/client/makeRpcRequest.d.ts

@@ -0,0 +1,11 @@
+import { ClientFunction, MappingTuple } from "./types";
+declare function makeRpcRequest<RequestPB, ResponsePB, Request extends Record<string, unknown>, Response extends Record<string, unknown>>(params: {
+    method: ClientFunction<RequestPB, ResponsePB>;
+    requestPBObjectConstructor: new () => RequestPB;
+    metadata: unknown;
+    request: Request;
+    enumMapping?: MappingTuple<unknown>;
+    objectMapping?: MappingTuple<unknown>;
+    repeatableObjectMapping?: MappingTuple<unknown>;
+}): Promise<Response>;
+export { makeRpcRequest };