chore(errors): add custom error classes (#508)

* fixing errors from earlier pull request

Signed-off-by: jriffs <[email protected]>

* removed unwanted file �ersion.ts??

Signed-off-by: jriffs <[email protected]>

* created more custom error classes and added test suites for them

Signed-off-by: jriffs <[email protected]>

---------

Signed-off-by: jriffs <[email protected]>

Author: jriffs

package.json

@@ -20,13 +20,14 @@
     "test:e2e:common:client": "./scripts/test-e2e-common.sh client",
     "test:e2e:common:server": "./scripts/test-e2e-common.sh server",
     "test:unit": "jest --runInBand --detectOpenHandles",
-    "test:unit:all": "npm run test:unit:main && npm run test:unit:http && npm run test:unit:grpc && npm run test:unit:actors && npm run test:unit:logger && npm run test:unit:utils",
+    "test:unit:all": "npm run test:unit:main && npm run test:unit:http && npm run test:unit:grpc && npm run test:unit:actors && npm run test:unit:logger && npm run test:unit:utils && npm run test:unit:errors",
     "test:unit:main": "NODE_ENV=test npm run test:unit 'test/unit/main/.*\\.test\\.ts'",
     "test:unit:http": "NODE_ENV=test npm run test:unit 'test/unit/http/.*\\.test\\.ts'",
     "test:unit:grpc": "NODE_ENV=test npm run test:unit 'test/unit/grpc/.*\\.test\\.ts'",
     "test:unit:actors": "NODE_ENV=test npm run test:unit 'test/unit/actor/.*\\.test\\.ts'",
     "test:unit:logger": "NODE_ENV=test npm run test:unit 'test/unit/logger/.*\\.test\\.ts'",
     "test:unit:utils": "NODE_ENV=test npm run test:unit 'test/unit/utils/.*\\.test\\.ts'",
+    "test:unit:errors": "NODE_ENV=test npm run test:unit 'test/unit/errors/.*\\.test\\.ts'",
     "lint": "eslint . --ext .js,.jsx,.ts,.tsx",
     "prebuild": "./scripts/prebuild.sh",
     "build-ci": "npm run prebuild && ./scripts/build.sh",

src/errors/GRPCNotSupportedError.ts

@@ -0,0 +1,19 @@
+/*
+Copyright 2023 The Dapr Authors
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+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.
+*/
+
+export class GRPCNotSupportedError extends Error {
+  readonly name = "GRPCNotSupportedError";
+  constructor() {
+    super("GRPC is currently not supported.");
+  }
+}

src/errors/HTTPNotSupportedError.ts

@@ -0,0 +1,19 @@
+/*
+Copyright 2023 The Dapr Authors
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+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.
+*/
+
+export class HTTPNotSupportedError extends Error {
+  readonly name = "HTTPNotSupportedError";
+  constructor() {
+    super("HTTP is currently not supported.");
+  }
+}

src/errors/PropertyRequiredError.ts

@@ -0,0 +1,22 @@
+/*
+Copyright 2023 The Dapr Authors
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+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.
+*/
+
+export class PropertyRequiredError extends Error {
+  readonly name = "PropertyRequiredError";
+  constructor(public propertyName: string) {
+    super(`${propertyName} is required`);
+    if (!propertyName || propertyName === " ") {
+      throw new PropertyRequiredError("propertyName");
+    }
+  }
+}

src/implementation/Client/GRPCClient/workflow.ts

@@ -14,6 +14,7 @@ limitations under the License.
 import GRPCClient from "./GRPCClient";
 import IClientWorkflow from "../../../interfaces/Client/IClientWorkflow";
 import { WorkflowGetResponseType } from "../../../types/workflow/WorkflowGetResponse.type";
+import { GRPCNotSupportedError } from "../../../errors/GRPCNotSupportedError";
 
 export default class GRPCClientWorkflow implements IClientWorkflow {
   client: GRPCClient;
@@ -23,7 +24,7 @@ export default class GRPCClientWorkflow implements IClientWorkflow {
   }
 
   get(_instanceId: string, _workflowComponent?: string | undefined): Promise<WorkflowGetResponseType> {
-    throw new Error("Method not implemented.");
+    throw new GRPCNotSupportedError();
   }
 
   start(
@@ -32,26 +33,26 @@ export default class GRPCClientWorkflow implements IClientWorkflow {
     _instanceId?: string | undefined,
     _workflowComponent?: string | undefined,
   ): Promise<string> {
-    throw new Error("Method not implemented.");
+    throw new GRPCNotSupportedError();
   }
 
   terminate(_instanceId: string, _workflowComponent?: string | undefined): Promise<any> {
-    throw new Error("Method not implemented.");
+    throw new GRPCNotSupportedError();
   }
 
   pause(_instanceId: string, _workflowComponent?: string | undefined): Promise<any> {
-    throw new Error("Method not implemented.");
+    throw new GRPCNotSupportedError();
   }
 
   resume(_instanceId: string, _workflowComponent?: string | undefined): Promise<any> {
-    throw new Error("Method not implemented.");
+    throw new GRPCNotSupportedError();
   }
 
   purge(_instanceId: string, _workflowComponent?: string | undefined): Promise<any> {
-    throw new Error("Method not implemented.");
+    throw new GRPCNotSupportedError();
   }
 
   raise(_instanceId: string, _eventName: string, _input?: any, _workflowComponent?: string | undefined): Promise<any> {
-    throw new Error("Method not implemented.");
+    throw new GRPCNotSupportedError();
   }
 }

src/implementation/Client/HTTPClient/configuration.ts

@@ -17,6 +17,7 @@ import { GetConfigurationResponse as GetConfigurationResponseResult } from "../.
 import HTTPClient from "./HTTPClient";
 import { SubscribeConfigurationCallback } from "../../../types/configuration/SubscribeConfigurationCallback";
 import { SubscribeConfigurationStream } from "../../../types/configuration/SubscribeConfigurationStream";
+import { HTTPNotSupportedError } from "../../../errors/HTTPNotSupportedError";
 
 export default class HTTPClientConfiguration implements IClientConfiguration {
   client: HTTPClient;
@@ -26,15 +27,15 @@ export default class HTTPClientConfiguration implements IClientConfiguration {
   }
 
   async subscribe(_storeName: string, _cb: SubscribeConfigurationCallback): Promise<SubscribeConfigurationStream> {
-    throw new Error("HTTP is currently not supported.");
+    throw new HTTPNotSupportedError();
   }
 
   async subscribeWithKeys(
     _storeName: string,
     _keys: string[],
     _cb: SubscribeConfigurationCallback,
   ): Promise<SubscribeConfigurationStream> {
-    throw new Error("HTTP is currently not supported.");
+    throw new HTTPNotSupportedError();
   }
 
   async subscribeWithMetadata(
@@ -43,10 +44,10 @@ export default class HTTPClientConfiguration implements IClientConfiguration {
     _metadata: KeyValueType,
     _cb: SubscribeConfigurationCallback,
   ): Promise<SubscribeConfigurationStream> {
-    throw new Error("HTTP is currently not supported.");
+    throw new HTTPNotSupportedError();
   }
 
   async get(_storeName: string, _keys: string[], _metadata?: KeyValueType): Promise<GetConfigurationResponseResult> {
-    throw new Error("HTTP is currently not supported.");
+    throw new HTTPNotSupportedError();
   }
 }

src/implementation/Client/HTTPClient/proxy.ts

@@ -15,6 +15,7 @@ import * as grpc from "@grpc/grpc-js";
 import Class from "../../../types/Class";
 import IClientProxy from "../../../interfaces/Client/IClientProxy";
 import HTTPClient from "./HTTPClient";
+import { HTTPNotSupportedError } from "../../../errors/HTTPNotSupportedError";
 
 export default class HTTPClientProxy implements IClientProxy {
   client: HTTPClient;
@@ -24,6 +25,6 @@ export default class HTTPClientProxy implements IClientProxy {
   }
 
   async create<T>(_cls: Class<T>, _clientOptions?: Partial<grpc.ClientOptions> | undefined): Promise<T> {
-    throw new Error("HTTP is currently not supported.");
+    throw new HTTPNotSupportedError();
   }
 }

src/implementation/Client/HTTPClient/workflow.ts

@@ -20,6 +20,7 @@ import { WorkflowStartOptions } from "../../../types/workflow/WorkflowStartOptio
 import { randomUUID } from "crypto";
 import { createHTTPQueryParam } from "../../../utils/Client.util";
 import { WorkflowRaiseOptions } from "../../../types/workflow/WorkflowRaiseOptions.type";
+import { PropertyRequiredError } from "../../../errors/PropertyRequiredError";
 
 export default class HTTPClientWorkflow implements IClientWorkflow {
   private readonly client: HTTPClient;
@@ -34,7 +35,7 @@ export default class HTTPClientWorkflow implements IClientWorkflow {
 
   async get(instanceID: string, workflowComponent?: string): Promise<WorkflowGetResponseType> {
     if (!instanceID) {
-      throw new Error("instanceID is required");
+      throw new PropertyRequiredError("instanceID");
     }
 
     workflowComponent = workflowComponent ?? HTTPClientWorkflow.DEFAULT_WORKFLOW_COMPONENT;
@@ -76,7 +77,7 @@ export default class HTTPClientWorkflow implements IClientWorkflow {
     options: WorkflowStartOptions = {},
   ): Promise<string> {
     if (!workflowName) {
-      throw new Error("workflowName is required");
+      throw new PropertyRequiredError("workflowName");
     }
 
     if (!instanceId) {
@@ -120,11 +121,11 @@ export default class HTTPClientWorkflow implements IClientWorkflow {
     options: WorkflowRaiseOptions = {},
   ): Promise<void> {
     if (!instanceId) {
-      throw new Error("instanceID is required");
+      throw new PropertyRequiredError("instanceID");
     }
 
     if (!eventName) {
-      throw new Error("eventName is required");
+      throw new PropertyRequiredError("eventName");
     }
 
     workflowComponent = workflowComponent ?? HTTPClientWorkflow.DEFAULT_WORKFLOW_COMPONENT;
@@ -170,11 +171,11 @@ export default class HTTPClientWorkflow implements IClientWorkflow {
 
   async _invokeMethod(instanceId: string, method: string, workflowComponent?: string | undefined): Promise<any> {
     if (!instanceId) {
-      throw new Error("instanceID is required");
+      throw new PropertyRequiredError("instanceID");
     }
 
     if (!method) {
-      throw new Error("method is required");
+      throw new PropertyRequiredError("method");
     }
 
     workflowComponent = workflowComponent ?? HTTPClientWorkflow.DEFAULT_WORKFLOW_COMPONENT;

src/implementation/Server/GRPCServer/actor.ts

@@ -15,6 +15,7 @@ import GRPCServer from "./GRPCServer";
 import IServerActor from "../../../interfaces/Server/IServerActor";
 import AbstractActor from "../../../actors/runtime/AbstractActor";
 import Class from "../../../types/Class";
+import { GRPCNotSupportedError } from "../../../errors/GRPCNotSupportedError";
 
 // https://docs.dapr.io/reference/api/bindings_api/
 export default class GRPCServerActor implements IServerActor {
@@ -25,18 +26,18 @@ export default class GRPCServerActor implements IServerActor {
   }
 
   deactivateActor(_actorType: string, _actorId: string): Promise<void> {
-    throw new Error("GRPC is currently not supported.");
+    throw new GRPCNotSupportedError();
   }
 
   init(): Promise<void> {
-    throw new Error("GRPC is currently not supported.");
+    throw new GRPCNotSupportedError();
   }
 
   getRegisteredActors(): Promise<string[]> {
-    throw new Error("GRPC is currently not supported.");
+    throw new GRPCNotSupportedError();
   }
 
   registerActor<T extends AbstractActor>(_cls: Class<T>): Promise<void> {
-    throw new Error("GRPC is currently not supported.");
+    throw new GRPCNotSupportedError();
   }
 }

test/unit/errors/PropertyRequiredError.test.ts

@@ -0,0 +1,41 @@
+/*
+Copyright 2023 The Dapr Authors
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+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.
+*/
+
+import { PropertyRequiredError } from "../../../src/errors/PropertyRequiredError";
+
+describe("PropertyRequiredError_class", () => {
+  // Tests that the constructor creates an instance of PropertyRequiredError
+  it("should be an instance of PropertyRequiredError", () => {
+    const error = new PropertyRequiredError("test");
+    expect(error).toBeInstanceOf(PropertyRequiredError);
+  });
+
+  // Tests that the constructor sets the propertyName property correctly
+  it("should set `propertyName` property correctly", () => {
+    const propertyName = "test";
+    const error = new PropertyRequiredError(propertyName);
+    expect(error.propertyName).toBe(propertyName);
+  });
+
+  // Tests that the constructor sets the message property correctly
+  it("should set `message` property correctly", () => {
+    const propertyName = "test";
+    const error = new PropertyRequiredError(propertyName);
+    expect(error.message).toBe(`${propertyName} is required`);
+  });
+
+  // Tests that the constructor throws an error
+  it("should throw an error if propertyName is an empty string", () => {
+    expect(() => new PropertyRequiredError("")).toThrow();
+  });
+});